Python XBee.at方法代码示例

# 需要导入模块: from xbee import XBee [as 别名]
# 或者: from xbee.XBee import at [as 别名]
def loop():

    global xb, telem, coord

    DEFAULT_COM_PORT = 'COM7'
    DEFAULT_BAUD_RATE = 57600
    DEFAULT_ADDRESS = '\x10\x21'
    DEFAULT_PAN = 0x1001
    
    if len(sys.argv) == 1:
        com = DEFAULT_COM_PORT
        baud = DEFAULT_BAUD_RATE
        addr = DEFAULT_ADDRESS
    elif len(sys.argv) == 4:
        com = sys.argv[1]
        baud = int(sys.argv[2])
        addr = pack('>H', int(sys.argv[3], 16))
    else:
        print "Wrong number of arguments. Must be: COM BAUD ADDR"
        sys.exit(1)
    
    ser = Serial(port = com, baudrate = baud) 
    xb = XBee(ser, callback = rxCallback)
    print "Setting PAN ID to " + hex(DEFAULT_PAN)
    xb.at(command = 'ID', parameter = pack('>H', DEFAULT_PAN))                 
    
    comm = CommandInterface(addr, txCallback)
    telem = TelemetryReader(addr, txCallback)
    kbint = KeyboardInterface(comm)
    coord = NetworkCoordinator(txCallback)
    
    comm.enableDebug()
    telem.setConsoleMode(True)
    telem.setFileMode(True)
    telem.writeHeader()
    coord.resume()
    
    comm.setSlewLimit(3.0)
    
    while True:

        try:
            c = None
            if( msvcrt.kbhit() ):
               c = msvcrt.getch()
            kbint.process(c)
            time.sleep(0.01)
            #comm.sendPing()

        except:        
            break
            
    telem.close()                
    xb.halt()
    ser.close()

# 需要导入模块: from xbee import XBee [as 别名]
# 或者: from xbee.XBee import at [as 别名]
def main(argv):

	#this is for all command line argument parsing
	SerialNumber = ''
	Command = ''
	Parameter = ''

	try:
		opts, args = getopt.getopt(argv,"s:c:p:",["SerialNumber=","Command=","Parameter="])

	except getopt.GetoptError:
		print 'argtest.py -s SerialNumber -c Command -p Parameter'
		sys.exit(2)

	for opt, arg in opts:
		if opt == '-h':
			print 'test.py -s <SerialNumber> -c <Command> -p <Parameter>'
			sys.exit()
		elif opt in ("-s", "SerialNumber"):
			SerialNumber = arg
		elif opt in ("-c", "Command"):
			Command = arg
		elif opt in ("-p", "Parameter"):
			Parameter = arg

	print 'Serial Number is:', SerialNumber
	print 'Command is:', Command
	print 'Parameter is:', Parameter

	#XBee Transmit Part
	PORT = '/dev/ttyAMA0'
	BAUD = 9600

	print 'start'

	ser = Serial(PORT, BAUD)
	print '1'
	xbee = XBee(ser)
	print '2'
	# Sends remote command from coordinator to the serial number, this only returns the value. In order to change
	#the value must add a parameter='XX'
	xbee.at(frame_id='A',command=Command, parameter=Parameter.decode('hex'))
	print '3'
	# Wait for and get the response
	frame = xbee.wait_read_frame()
	
	print '4'
	print frame
	ser.close()

# 需要导入模块: from xbee import XBee [as 别名]
# 或者: from xbee.XBee import at [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
    """
    ser = serial.Serial('/dev/ttyUSB0', 57600)
    xbee = XBee(ser)
    rid = zc_id.get_id()
    rid = rid.split("/",1)[1] 
    xbee.at(frame='A', command='MY', parameter='\x20'+chr(int(rid)))
    xbee.at(frame='B', command='CH', parameter='\x0e')
    xbee.at(frame='C', command='ID', parameter='\x99\x99')
    f = open("data.csv","w")    
    try:
        i = 0
        while(1):
            response = xbee.wait_read_frame()
            print response
            lastRSSI = ord(response.get('rssi'))
            lastAddr = response.get('source_addr')
            print "RSSI = -%d dBm @ %d at index %d" % (lastRSSI,ord(lastAddr[1]), i)
            data = str(i) + ", -" + str(lastRSSI) +"\n"
            f.write(data)
            i = i+1
    except KeyboardInterrupt:
        pass
    finally:
        f.close()
        ser.close()

# 需要导入模块: from xbee import XBee [as 别名]
# 或者: from xbee.XBee import at [as 别名]
class BaseStation(object):

    def __init__(self, port, baud, dest_addr = None, call_back = None):
        self.ser = Serial(port, baud, timeout = 1)
        self.ser.writeTimeout = 5

        if call_back == None:
            self.xb = XBee(self.ser)
        else:
            self.xb = XBee(self.ser, callback = call_back)
        
        self.dest_addr = dest_addr

    def close(self):
        try:
            self.xb.halt()
            self.ser.close()
        except SerialException:
            print "SerialException"

    def sendTX(self, status, type, data ):
        pld = chr(status) + chr(type)  + ''.join(data)
        self.xb.tx(dest_addr = self.dest_addr, data = pld)
        time.sleep(0.1)
        
    def sendAT(self, command, parameter = None, frame_id = None):
        if parameter is not None:
            if frame_id is not None:
                self.xb.at(frame_id = frame_id, command = command, parameter = parameter)
            else:
                self.xb.at(command = command, parameter = parameter)
        elif frame_id is not None:
            self.xb.at(frame_id = frame_id, command = command)
        else:
            self.xb.at(command = command)
        time.sleep(0.1)

    def read(self):
        packet = self.xb.wait_read_frame()

        return packet
        

# 需要导入模块: from xbee import XBee [as 别名]
# 或者: from xbee.XBee import at [as 别名]
def loop():

    DEFAULT_COM_PORT = 'COM7'
    DEFAULT_BAUD_RATE = 57600
    DEFAULT_ADDRESS = '\x10\x21'
    DEFAULT_PAN = '\x10\x01'
    
    
    if len(sys.argv) == 1:
        com = DEFAULT_COM_PORT
        baud = DEFAULT_BAUD_RATE
        addr = DEFAULT_ADDRESS
    elif len(sys.argv) == 4:
        com = sys.argv[1]
        baud = int(sys.argv[2])
        addr = pack('>H', int(sys.argv[3], 16))
    else:
        print "Wrong number of arguments. Must be: COM BAUD ADDR"
        sys.exit(1)
                
    coord = CommandInterface(addr, txCallback)
    coord.enableDebug()
    
    ser = Serial(port = com, baudrate = baud) 
    xb = XBee(ser)
    print "Setting PAN ID to " + hex(DEFAULT_PAN)
    xb.at(command = 'ID', parameter = pack('>H', DEFAULT_PAN))         
    
    thrust = 0.0
    yaw = 0.0
    elevator = 0.0
    
    while True:
        
        try:                    
            
            c = msvcrt.getch()
            
            if c == 'w':
                thrust = thrust + THRUST_INCREMENT
            elif c == 'a':
                yaw = yaw + YAW_INCREMENT                
            elif c == 's':
                thrust = thrust - THRUST_INCREMENT
            elif c == 'd':
                yaw = yaw - YAW_INCREMENT                
            elif c == 'r':
                elevator = elevator + ELEVATOR_INCREMENT
            elif c == 'f':
                elevator = elevator - ELEVATOR_INCREMENT
            elif c == 'q':
                thrust = 0.0
                yaw = 0.0
                elevator = 0.0
            elif c == 'e':
                break
            elif c == 't':
                coord.setRegulatorMode(RegulatorStates['Remote Control'])            
                
            if thrust > THRUST_UPPER_LIMIT:
                thrust = THRUST_UPPER_LIMIT
            elif thrust < THRUST_LOWER_LIMIT:
                thrust = THRUST_LOWER_LIMIT
                
            if yaw > YAW_UPPER_LIMIT:
                yaw = YAW_UPPER_LIMIT
            elif yaw < YAW_LOWER_LIMIT:
                yaw = YAW_LOWER_LIMIT
            
            if elevator > ELEVATOR_UPPER_LIMIT:
                elevator = ELEVATOR_UPPER_LIMIT
            elif elevator < ELEVATOR_LOWER_LIMIT:
                elevator = ELEVATOR_LOWER_LIMIT
            
            coord.setRemoteControlValues(thrust, yaw, elevator)
            
        except:
        
            print "Exception: ", sys.exc_info()[0]
            break
                    
    xb.halt()
    ser.close()

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

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

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

print xbee.at(command='ND')

while 0:

    packet = xbee.wait_read_frame()
    print packet
    # print packet['source_addr'], packet['id'], packet['rssi'], packet['options']

    if packet['id'] == 'rx_io_data':

        if packet['source_addr'] == '\x00\x12':
            print packet['source_addr']

#MAC, number written on the back of the XBee module
# CO3 = my coordinator
# EP1 = my endpoint with the LED on pin 11

device={
        "CO3":'\x00\x00\x00\x00\x00\x00\x00\x00',
        "EP1":'\x00\x13\xa2\x00\x40\x64\x71\x68'

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

    elif len(sys.argv) == 5:
        com = sys.argv[1]
        baud = int(sys.argv[2])
        addr = pack(">H", int(sys.argv[3], 16))
        iters = int(sys.argv[4])

    coord = CommandInterface(addr, txCallback)
    coord.enableDebug()

    # Enable XBee
    ser = Serial(port=com, baudrate=baud)
    xb = XBee(ser, callback=processPacket)
    print "Setting PAN ID to " + hex(DEFAULT_PAN)
    xb.at(command="ID", parameter=pack(">H", DEFAULT_PAN))

    # Create file
    today = datetime.today()
    d = str(today.year) + "_" + str(today.month) + "_" + str(today.day)
    t = str(today.hour) + "_" + str(today.minute) + "_" + str(today.second)
    fname = "Latency_Test-" + d + "-" + t + ".txt"
    record_log = open(fname, "w")

    raw_input("Press any key to begin test...")

    capture_times = []
    roundtrip_times = []

    # Get iters number of samples
    for i in range(0, iters):

# 需要导入模块: from xbee import XBee [as 别名]
# 或者: from xbee.XBee import at [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
    """
    ser = serial.Serial('/dev/ttyUSB0', 57600)
    xbee = XBee(ser)
    rid = zc_id.get_id()
    rid = rid.split("/",1)[1] 
    xbee.at(frame='A', command='MY', parameter='\x20'+chr(int(rid)))
    xbee.at(frame='B', command='CH', parameter='\x0e')
    xbee.at(frame='C', command='ID', parameter='\x99\x99')


    sample = 30

    ch1_list = []
    ch6_list = []
    ch11_list = []
    f = open("data.csv","w")    
    try:
        i = 0
        while(1):

            xbee.at(frame='B', command='CH', parameter='\x0e')
            response = xbee.wait_read_frame()
            #print response
            lastRSSI = ord(response.get('rssi'))
            lastAddr = response.get('source_addr')
            ch1_list.append(lastRSSI)
            if len(ch1_list) > sample:
                ch1_list = []
            #print "RSSI = -%d dBm @ %d at index %d" % (lastRSSI,ord(lastAddr[1]), i)
            #data = str(i) + ", -" + str(lastRSSI) +"\n"
            #f.write(data)
            #i = i+1

            xbee.at(frame='B', command='CH', parameter='\x13')
            response = xbee.wait_read_frame()
            #print response
            lastRSSI = ord(response.get('rssi'))
            lastAddr = response.get('source_addr')
            ch6_list.append(lastRSSI)
            if len(ch6_list) > sample:
                ch6_list = []


            xbee.at(frame='B', command='CH', parameter='\x18')
            response = xbee.wait_read_frame()
            #print response
            lastRSSI = ord(response.get('rssi'))
            lastAddr = response.get('source_addr')
            ch11_list.append(lastRSSI)
            if len(ch11_list) > sample:
                ch11_list = []
            
            if len(ch1_list) == sample:
                print "ch1_list max: ", max(ch1_list), " std: ", np.std(ch1_list)
                print "ch6_list max: ", max(ch6_list), " std: ", np.std(ch6_list)
                print "ch11_list max: ", max(ch11_list), " std: ", np.std(ch11_list)
                std = [np.std(ch1_list),np.std(ch6_list),np.std(ch11_list)]

                for i in range(3):
                    if std[i] == min(std):
                        break
                
                if i == 0:
                    print "result: ", max(ch1_list)
                if i == 1:
                    print "result: ", max(ch6_list)
                if i == 2:
                    print "result: ", max(ch11_list)

                print  " "

    except KeyboardInterrupt:
        pass
    finally:
        f.close()
        ser.close()

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

# In[4]:

#ls /dev/ttyACM*


# In[5]:

r0=Robot('/dev/ttyACM0')

# xbee setup

ser = serial.Serial('/dev/ttyUSB0', 57600)
xbee = XBee(ser)
xbee.at(frame='A', command='MY', parameter='\x20\x01')
xbee.at(frame='B', command='CH', parameter='\x0e')
xbee.at(frame='C', command='ID', parameter='\x99\x99')




# In[6]:

r0.cmd(.3, .3)
time.sleep(10)
r0.cmd(0, 0)
#while(True):
    #print "in the loop"
    # try:
    #    response = xbee.wait_read_frame()

# 需要导入模块: from xbee import XBee [as 别名]
# 或者: from xbee.XBee import at [as 别名]
class XbRssi(object):
    # initialization
    def __init__(self, serial_port): 
        self.ser = serial.Serial(serial_port, 57600)
        self.xbee = XBee(self.ser)
        self.rid = zc_id.get_id()
        self.rid = self.rid.split("/",1)[1] 
        self.id = chr(int(self.rid))
        self.xbee.at(frame='A', command='MY', parameter='\x20'+chr(int(self.rid)))
        self.xbee.at(frame='B', command='CH', parameter='\x0e')
        self.xbee.at(frame='C', command='ID', parameter='\x99\x99')
        self.updateTransmitThread = threading.Thread(target=self.transmit_loop)
        self.updateTransmitThread.daemon = True
        self.updateReceiveThread = threading.Thread(target=self.receive_loop)
        self.updateReceiveThread.daemon = True
        self.transmit_peroid = 0.01     # in second

        self.response = 0
        self.rssi = 0
        self.addr = 0
        self.data = 0
        self.sendMessage = ''
        self.transmit = True

        #self.response = self.xbee.wait_read_frame()
        #self.rssi = -ord(self.response.get('rssi'))
        #self.addr = ord(self.response.get('source_addr')[1])
        #self.data = self.response.get('rf_data')

        self.pktNum = 0
        self.sendingCommand = False
        self.ser.flush()

    # define transmit and receive loop
    def transmit_loop(self):
        while True:
            self.transmit_rssi()

    def receive_loop(self):
        while True:
            self.response = self.xbee.wait_read_frame()
            self.rssi = -ord(self.response.get('rssi'))
            self.addr = ord(self.response.get('source_addr')[1])
            self.data = self.response.get('rf_data')
            #print self.data + ", RSSI = %d dBm @ address %d" % ( self.rssi, self.addr )
    
    # transmitter function
    def transmit_rssi(self):
        if (self.transmit == True):
            if (self.sendingCommand == False):
                msg = self.build_packet_prefix()
            else:
                msg = self.build_packet_prefix() + self.sendMessage
            #print "Sending Msg:" + msg
            self.xbee.tx(dest_addr='\xFF\xFF', data = msg)
            self.pktNum = self.pktNum + 1
            time.sleep(self.transmit_peroid)
        else:
            time.sleep(5)

    # get 30 received rssi values
    def get_rssi_list(self):
        rssi_list = []
        index_list = []
        
        rssi_list.append(self.rssi)
        index_list.append(self.get_index(self.data))

        i = 1
        while i < 30:
            index = self.get_index(self.data)

            if index != index_list[-1]:
                rssi_list.append(self.rssi)
                index_list.append(index)
                i = i + 1

            time.sleep(self.transmit_peroid)

        return rssi_list

    # data processing functions
    def get_max_rssi(self):
        rssi_list = self.get_rssi_list()
        rssi_max = max(rssi_list)
        return rssi_max, rssi_list

    def get_min_rssi(self):
        rssi_list = self.get_rssi_list()
        rssi_min = min(rssi_list)
        return rssi_min, rssi_list

    def get_med_rssi(self):
        rssi_list = self.get_rssi_list()
        rssi_med = median(rssi_list)
        return rssi_med, rssi_list

    def get_avg_rssi(self):
        rssi_list = self.get_rssi_list()
        rssi_avg = mean(rssi_list)
#.........这里部分代码省略.........

# 需要导入模块: from xbee import XBee [as 别名]
# 或者: from xbee.XBee import at [as 别名]
def loop():

    global xb, telem, coord

    DEFAULT_COM_PORT = 'COM7'
    DEFAULT_BAUD_RATE = 57600
    DEFAULT_ADDRESS = '\x10\x21'
    DEFAULT_PAN = 0x1001
    
    if len(sys.argv) == 1:
        com = DEFAULT_COM_PORT
        baud = DEFAULT_BAUD_RATE
        addr = DEFAULT_ADDRESS
    elif len(sys.argv) == 4:
        com = sys.argv[1]
        baud = int(sys.argv[2])
        addr = pack('>H', int(sys.argv[3], 16))
    else:
        print "Wrong number of arguments. Must be: COM BAUD ADDR"
        sys.exit(1)
    
    ser = Serial(port = com, baudrate = baud) 
    xb = XBee(ser, callback = rxCallback)
    print "Setting PAN ID to " + hex(DEFAULT_PAN)
    xb.at(command = 'ID', parameter = pack('>H', DEFAULT_PAN))                 
    
    comm = CommandInterface(addr, txCallback)
    telem = TelemetryReader(addr, txCallback)
    kbint = KeyboardInterface(comm)
    coord = NetworkCoordinator(txCallback)
    
    comm.enableDebug()
    telem.setConsoleMode(True)
    telem.setFileMode(True)
    telem.writeHeader()
    coord.resume()
    
    comm.setSlewLimit(3.0)
    
    while True:

        try:   
            # Copied from code.activestate.com/recipes/134892/
            # TODO: Find a way to avoid this blocking call
            fd = sys.stdin.fileno()
            old_settings = termios.tcgetattr(fd)
            try:
                tty.setraw(sys.stdin.fileno())
                c = sys.stdin.read(1)
            finally:
                termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)             
            kbint.process(c)
            time.sleep(0.01)
            #comm.sendPing()
    
        except:        
            break
            
    telem.close()                
    xb.halt()
    ser.close()

# 需要导入模块: from xbee import XBee [as 别名]
# 或者: from xbee.XBee import at [as 别名]
class XbRssi:
    def __init__(self, serial_port): 
        self.ser = serial.Serial(serial_port, 57600)
        self.xbee = XBee(self.ser)
        self.rid = zc_id.get_id()
        self.rid = self.rid.split("/",1)[1] 
        self.id = chr(int(self.rid))
        self.xbee.at(frame='A', command='MY', parameter='\x20'+chr(int(self.rid)))
        self.xbee.at(frame='B', command='CH', parameter='\x0e')
        self.xbee.at(frame='C', command='ID', parameter='\x99\x99')
        self.updateTransmitThread = threading.Thread(target=self.transmit_loop)
        self.updateTransmitThread.daemon = True
        self.updateReceiveThread = threading.Thread(target=self.receive_loop)
        self.updateReceiveThread.daemon = True
        self.response = 0
        self.pktNum = 0
        self.predecessor = 0
        self.successor = 0
        self.transmit = True
        self.ascend = False
        self.descend = False
        self.sendMessage = self.id+'PKT'


    def transmit_loop(self):
        while True:
            self.transmit_rssi()
	    time.sleep(0.1)
    def receive_loop(self):
        while True:
            # self.collect_max_rssi()
            self.receive_pkt()
            self.decode_msg()

    def transmit_rssi(self):
        print "Sending packet #",self.pktNum,self.sendMessage
        #message = ''.join(['Hello #', repr(self.pktNum)] )
        if (self.transmit == True):
            self.xbee.tx(dest_addr='\xFF\xFF', data = self.sendMessage)
            self.pktNum = self.pktNum + 1
            #time.sleep(0.001)

    def send_msg(self, msg):
	self.xbee.tx(dest_addr='\xFF\xFF', data = msg)
	self.pktNum = self.pktNum + 1

    def receive_pkt(self):
        self.response = self.xbee.wait_read_frame()
        print self.get_data() + ", RSSI = -%d dBm @ address %d" % ( self.get_rssi(), self.get_addr() )
    
    def collect_max_rssi(self):
        # print "inside collect_max_rssi()"
        self.receive_pkt()
        current_max_rssi = self.get_rssi()
        current_max_pkt  = self.get_data()
        for i in range(30):
            # print "inside for loop"
            self.receive_pkt()
            self.decode_msg()
            next_rssi = self.get_rssi()
            next_pkt  = self.get_data()
            if next_rssi > current_max_rssi:
                # print "inside if statemene"
                current_max_rssi = next_rssi
                current_max_pkt  = next_pkt
            #print "rssi=" + str(current_max_rssi) + ", pkt=" + next_pkt
        return current_max_rssi
    def decode_msg(self):
        if (self.response != 0):
            msg =  self.get_data()
            #print msg
            if msg.startswith('TRANSMIT_START'):
                if (self.predecessor == self.get_sender_id(msg)):
                    self.transmit = True
                    self.sendMessage = 'ACK_TRANSMIT_START'
            elif msg.startswith('TRANSMIT_STOP'):
                print 'Setting transmit flag to false'
                self.transmit = False               
            elif msg.startswith('ASCEND_START'):
                self.ascend = True
                print 'Starting Gradient Ascend'
                self.sendMessage = 'ACK_ASCEND_START'
            elif msg.startswith('DESCEND_START'):
                self.descend = True
                print 'Starting Gradient Descend'
                self.sendMessage = 'ACK_DESCEND_START'
            elif msg.startswith('ARRIVAL'):
                self.chain_next_bot(msg)
                self.sendMessage = 'ACK_ARRIVAL'
            elif msg.startswith('SET_PREDECESSOR'):
                self.set_predecessor(msg)
                self.sendMessage = 'ACK_SET_PREDECESSOR'
            elif msg.startswith('ACK'):
                self.sendMessage = 'STOP_ACK'
            elif msg.startswith('STOP_ACK'):
                self.sendMessage = ''.join(['Hello #', repr(self.pktNum)] )
        else:
            return 0

    def send_arrival_signal(self):
#.........这里部分代码省略.........

# 需要导入模块: from xbee import XBee [as 别名]
# 或者: from xbee.XBee import at [as 别名]
class BaseStation(object):

    api_frame = 'A'
    pendingAT = False

    def __init__(self, port, baudrate, channel = None, PANid = None, base_addr = None, verbose = False):
        
        self.verbose = verbose
        
        try:
            self.ser = serial.Serial(port, baudrate, timeout = 1)
        except serial.SerialException:
            print
            print "Could not open serial port:",port
            print
            print "Scanning for available COM ports:"
            print "------------------------------------"
            scanSerialPorts()
            print "------------------------------------"
            print "Check your BaseStation declaration --OR--"
            print " you may need to change the port in shared.py"
            sys.exit() #force exit
        
        if verbose:
            print "serial open"
            
        self.ser.writeTimeout = 5

        #Set up callback
        self.xb = XBee(self.ser, callback = self.xbee_received)

    def close(self):
        try:
            self.xb.halt()
            self.ser.close()
            print "BaseStation halted and close."
        except SerialException:
            print "SerialException on Basestation close() attempt."

    def sendTX(self, status, type, data ):
        pld = chr(status) + chr(type)  + ''.join(data)
        self.xb.tx(dest_addr = self.dest_addr, data = pld)
        time.sleep(0.1)
        
    def sendAT(self, command, parameter = None, frame_id = None):
    #TODO: This logic may not be correct. Need to sort out condition where frame id and parameters are used
        if frame_id is None:
            #Send with no wait
            if parameter is not None:
                self.xb.at(command = command, parameter = parameter)
            else:
                self.xb.at(command = command)
        else: #use frame_id
            #send with wait
            if parameter is not None:
                self.xb.at(frame_id = frame_id, command = command, parameter = parameter)
            else:
                self.xb.at(frame_id = frame_id, command = command)
            
            self.ATwait()
            
        #if parameter is not None:
        #    if frame_id is not None:
        #        self.xb.at(frame_id = frame_id, command = command, parameter = parameter)
        #    else:
        #        self.xb.at(command = command, parameter = parameter)
        #elif frame_id is not None: # expects an AT response
        #    self.xb.at(frame_id = frame_id, command = command)
            #Since an AT response is expected, this function will busy wait here for the AT response
        #    self.ATwait()
        #else:
        #    self.xb.at(command = command)

    def read(self):
        packet = self.xb.wait_read_frame()
        return packet

    def getChannel(self):
        self.incremetAPIFrame()
        self.sendAT(command='CH', frame_id = self.api_frame)
        return self.atResponseParam

    def setChannel(self, param):
        self.incremetAPIFrame()
        self.sendAT(command='CH', parameter=param, frame_id = self.api_frame)

    def getPanID(self):
        self.incremetAPIFrame()
        self.sendAT(command='ID', frame_id = self.api_frame)
        return self.atResponseParam
        
    def setPanID(self, param):
        self.incremetAPIFrame()
        self.sendAT(command='ID', parameter=param, frame_id = self.api_frame)
        
    def getSrcAddr(self):
        self.incremetAPIFrame()
        self.sendAT(command='MY', frame_id = self.api_frame)
        return self.atResponseParam
        
#.........这里部分代码省略.........

# 需要导入模块: from xbee import XBee [as 别名]
# 或者: from xbee.XBee import at [as 别名]
 DEFAULT_UPDATE_RATE = 0.1 # Directory broadcast rate in hertz
 
 if len(sys.argv) == 1:
     com = DEFAULT_COM_PORT
     baud = DEFAULT_BAUD_RATE
 elif len(sys.argv) == 3:
     com = sys.argv[1]
     baud = int(sys.argv[2])
             
 networkcoordinator = NetworkCoordinator(txCallback)
 
 ser = Serial(port = com, baudrate = baud)
 xb = XBee(ser, callback = networkcoordinator.processPacket)
 
 print "Setting Local Address to " + hex(networkcoordinator.localAddress)
 xb.at(command = 'MY', parameter = pack('>H', networkcoordinator.localAddress))
 print "Setting PAN ID to " + hex(networkcoordinator.localPAN)
 xb.at(command = 'ID', parameter = pack('>H', networkcoordinator.localPAN))
 
 networkcoordinator.resume()
 
 sleepTime = 1.0/DEFAULT_UPDATE_RATE
 
 while True:
     try:
         time.sleep(sleepTime)
         networkcoordinator.sendDirectory()
     except:            
         networkcoordinator.close()
         break
 xb.halt()

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

ser = serial.Serial('/dev/tts/0', 9600)
xb = XBee(ser) 
xb.at(command='ND')  # Send Node Discovery command (ATND) 
while True: 
    try:
        frame = xb.wait_read_frame() 
        print frame 
    except KeyboardInterrupt: 
        break 

ser.close()