Python XBee.wait_read_frame方法代码示例

# 需要导入模块: from xbee import XBee [as 别名]
# 或者: from xbee.XBee import wait_read_frame [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 wait_read_frame [as 别名]
def main():

    try:
        ser = serial.Serial('/dev/ttyUSB0', 38400)
        xbee = XBee(ser)
        print 'xbee created/initialized'

        with open('flight_data.csv', 'w') as outfile:
            outfile.write(','.join(headers))
            outfile.write('\n')

        try:
            while True:
                packet = xbee.wait_read_frame()
                data = struct.unpack('qddfffffffffhhhcx', packet['rf_data'])
                with open('flight_data.csv', 'a+w') as outfile:
                    outfile.write(','.join([str(i) for i in data]))
                    outfile.write('\n')

        except KeyboardInterrupt:
            print 'Process stopped by user'

        finally:
            xbee = None
            ser.close()

    except serial.SerialException:
        print 'failed to initialize serial connection'

# 需要导入模块: from xbee import XBee [as 别名]
# 或者: from xbee.XBee import wait_read_frame [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 wait_read_frame [as 别名]
def main():
    ser = serial.Serial(SERIALPORT, BAUDRATE, timeout=60)
    xbee = XBee(ser)

    # Receieve one data frame from the xbee
    xb = xbee.wait_read_frame()

    # Record the time for the reading
    logtime = datetime.datetime.now()

    # Split out the xbee data packet into variables that are easy to work with
    #xid = xb['id']
    #options = int(binascii.hexlify(xb['options']), 16)
    rssi = -1 * int(binascii.hexlify(xb['rssi']), 16)
    #source_addr = int(binascii.hexlify(xb['source_addr']), 16)
    data = xb['rf_data']
    pressure = struct.unpack('f', data[0:4])[0]
    temperature = struct.unpack('f', data[4:8])[0]

    # Post to database
    con = mdb.connect(host='localhost', db='monitor', user='crblackw')

    with con:
        cur = con.cursor()
        cur.execute("INSERT INTO "
                    "outdoor (datetime, rssi, temperature, pressure) "
                    "VALUES (%s, %s, %s, %s)",
                    (logtime, rssi, temperature, pressure))

    con.close()

# 需要导入模块: from xbee import XBee [as 别名]
# 或者: from xbee.XBee import wait_read_frame [as 别名]
class Dispatch(object):
    def __init__(self, ser=None, xbee=None):
        self.xbee = None
        if xbee:
            self.xbee = xbee
        elif ser:
            self.xbee = XBee(ser)

        self.handlers = []
        self.names = set()

    def register(self, name, callback, filter):
        """
        register: string, function: string, data -> None, function: data -> boolean -> None
        
        Register will save the given name, callback, and filter function
        for use when a packet arrives. When one arrives, the filter
        function will be called to determine whether to call its associated
        callback function. If the filter method returns true, the callback
        method will be called with its associated name string and the packet
        which triggered the call.
        """
        if name in self.names:
            raise ValueError("A callback has already been registered with the name '%s'" % name)

        self.handlers.append({"name": name, "callback": callback, "filter": filter})

        self.names.add(name)

    def run(self, oneshot=False):
        """
        run: boolean -> None
        
        run will read and dispatch any packet which arrives from the 
        XBee device
        """
        if not self.xbee:
            raise ValueError("Either a serial port or an XBee must be provided to __init__ to execute run()")

        while True:
            self.dispatch(self.xbee.wait_read_frame())

            if oneshot:
                break

    def dispatch(self, packet):
        """
        dispatch: XBee data dict -> None
        
        When called, dispatch checks the given packet against each 
        registered callback method and calls each callback whose filter 
        function returns true.
        """
        for handler in self.handlers:
            if handler["filter"](packet):
                # Call the handler method with its associated
                # name and the packet which passed its filter check
                handler["callback"](handler["name"], packet)

# 需要导入模块: from xbee import XBee [as 别名]
# 或者: from xbee.XBee import wait_read_frame [as 别名]
class BasestationStream(threading.Thread):
  def __init__(self, port='COM1', baudrate=230400, addr=0x2071, sinks=None, autoStart=True):
    
    threading.Thread.__init__(self)
    self.daemon = True
    
    self.robots = {}
    
    try:
      self.ser = serial.Serial(port, baudrate, timeout=3, rtscts=0)
      self.xb = XBee(self.ser)
    except serial.serialutil.SerialException:
      print "Could not open serial port:%s" % port
      self.xb = None
    
    self.dispatcher=AsynchDispatch(sinks=sinks,
      callbacks={'packet':[self.send]})
      
    self.addr = addr
        
    if autoStart:
        self.start()
        
  def run(self):
    if self.xb is not None:
      while(True):
        data = self.xb.wait_read_frame()
        self.receive_callback(data)
        
  def exit(self):
    if self.xb is not None:
      self.xb.halt()
      self.ser.close()
      self.xb = None
    
  def put(self,message):
    self.dispatcher.put(message)
    
  def receive_callback(self,xbee_data):
    self.last_time = time.time()
    pkt = Packet(dest_addr=self.addr, time=self.last_time,
      payload=xbee_data.get('rf_data'))
      
    source_addr = unpack('>h',xbee_data.get('source_addr'))
    source_addr = source_addr[0]
    
    if source_addr in self.dispatcher.sinks.keys():
      self.dispatcher.dispatch((source_addr,pkt))
    else:
      self.dispatcher.dispatch(('packet',pkt))
    
  def send(self,message):
    if self.xb is not None:
      pkt = message.data
      self.xb.tx(dest_addr = pack('>h',pkt.dest_addr), data = pkt.payload)
  
  def register_robot(self,robot,addr):
    self.dispatcher.add_sinks({addr:[robot.put]})

# 需要导入模块: from xbee import XBee [as 别名]
# 或者: from xbee.XBee import wait_read_frame [as 别名]
class BaseStation(object):
    def __init__(self, port, baud, dest_addr=None, call_back=None):
        try:
            self.ser = Serial(port, baud, timeout=1)
            if self.ser.isOpen():
                if call_back == None:
                    self.xb = XBee(self.ser)
                else:
                    self.xb = XBee(self.ser, callback=call_back)
            else:
                raise SerialException("")
        except (AttributeError, SerialException):
            print "Unable to open a connection to the target. Please" + "  verify your basestation is enabled and properly configured."
            raise

        self.ser.writeTimeout = 5
        self.dest_addr = dest_addr

    def close(self):
        try:
            self.xb.halt()
            self.ser.close()
        except (AttributeError, SerialException):
            print "Serial Exception"
            raise

    def send(self, status, type, data):
        pld = Payload("".join(data), status, type)
        self.xb.tx(dest_addr=self.dest_addr, data=str(pld))

    def write(self, data):
        status = 0x00
        type = 0x00
        data_length = len(data)
        start = 0

        while data_length > 0:
            if data_length > 80:
                self.send(status, type, data[start : start + 80])
                data_length -= 80
                start += 80
            else:
                self.send(status, type, data[start : len(data)])
                data_length = 0
            time.sleep(0.05)

    def read(self):
        packet = self.xb.wait_read_frame()
        pld = Payload(packet.get("rf_data"))
        # rssi = ord(packet.get('rssi'))
        # (src_addr, ) = unpack('H', packet.get('source_addr'))
        # id = packet.get('id')
        # options = ord(packet.get('options'))
        status = pld.status
        type = pld.type
        data = pld.data
        return data

# 需要导入模块: from xbee import XBee [as 别名]
# 或者: from xbee.XBee import wait_read_frame [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 send(self, status, type, data ):
        pld = Payload( ''.join(data), status, type )
        self.xb.tx(dest_addr = self.dest_addr, data = str(pld))

    def write(self, data):
        status = 0x00
        type = 0x00
        data_length = len(data)
        start = 0
        

        while(data_length > 0):
            if data_length > 80:
                self.send( status, type, data[start:start+80] )
                data_length -= 80
                start += 80
            else:
                self.send( status, type, data[start:len(data)] )
                data_length = 0
            time.sleep(0.05)
            

    def read(self):
        packet = self.xb.wait_read_frame()
    
        pld = Payload(packet.get('rf_data'))
        #rssi = ord(packet.get('rssi'))
        #(src_addr, ) = unpack('H', packet.get('source_addr'))
        #id = packet.get('id')
        #options = ord(packet.get('options'))
        
        status = pld.status
        type = pld.type
        data = pld.data
   
        return data

# 需要导入模块: from xbee import XBee [as 别名]
# 或者: from xbee.XBee import wait_read_frame [as 别名]
def main():
    ser = serial.Serial('', 9600)
    xbee = XBee(ser)
    while True:
        try:
            response = xbee.wait_read_frame()
            print response
        except KeyboardInterrupt:
            break
    ser.close()

# 需要导入模块: from xbee import XBee [as 别名]
# 或者: from xbee.XBee import wait_read_frame [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 wait_read_frame [as 别名]
def getSensorReading(serialPort):
    """
    Read data from sensor.

    serial_port: A string with the port number where the xbee reciever is connected
    for windows system is something like 'COM3','COM4'.. etc
    for Linux/Unix systems should be something lik '/dev/ttyUSB0', '/dev/ttyUSB1' ...etc

    """
    ser = serial.Serial(serialPort, 9600)  # Serial port to which the reciever is connected
    xbee = XBee(ser)  # Xbee object
    response = xbee.wait_read_frame()  # get reading
    response["timestamp"] = datetime.now()
    ser.close()
    return response

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

  def sendToController(self, msg):
    resplen = len(msg)
    self.xbee.tx(dest_addr='\x00\x00', data="lr:"+str(resplen))
    sentlen = 0
    while sentlen <= resplen:
      endindex = sentlen + 98
      if (endindex > resplen):
	line = msg[sentlen:]
      else:
	line = msg[sentlen:endindex]
      self.xbee.tx(dest_addr='\x00\x00', data="r:"+line)
      sentlen += 98

  def sendAnnounce(self, msg):
      self.xbee.tx(dest_addr='\x00\x00', data="a:"+msg)
      
  def clientLoop(self):	
    # initial beacon to the controller
    self.sendAnnounce("By your command-drone is awaiting orders")
    
    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
	  proc = subprocess.Popen(cmd['rf_data'][2:], stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
	  signal.alarm(60)
	  rc = proc.wait()
	  signal.alarm(0)
	  if (rc == 0): #returned successfully
	    for line in iter(proc.stdout.readline, ''):
	      self.sendToController(line)
	  else:
	    self.sendToController("Error: process returned " + str(rc) + "\n")
      except KeyboardInterrupt:
	break
      except Alarm:
	self.sendToController("Error: process timed out")
	signal.alarm(0)
    self.serial_port.close()

# 需要导入模块: from xbee import XBee [as 别名]
# 或者: from xbee.XBee import wait_read_frame [as 别名]
class BaseStation(object):
    def __init__(self, port = DEFAULT_SERIAL_PORT, baud = DEFAULT_BAUD_RATE, dest_addr = DEFAULT_DEST_ADDR):
        self.ser = Serial(port, baud, timeout = 1)
        self.ser.writeTimeout = 5
        self.xb = XBee(self.ser)
        self.dest_addr = dest_addr

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

    def write(self, data):
        status = 0x00
        type = 0x00
        data_length = len(data)
        start = 0
        end = 80

        while(data_length > 0):
            if data_length > 80:
                pld = Payload(''.join(data[start:start+80]), status, type )
                data_length -= 80
                start += 80
            else:
                pld = Payload(''.join(data[start:len(data)]), status, type )
                data_length = 0
            self.xb.tx(dest_addr = self.dest_addr, data = str(pld))
            time.sleep(0.05)
            
    def read(self, length = 0):
        packet = self.xb.wait_read_frame()
    
        pld = Payload(packet.get('rf_data'))
        #rssi = ord(packet.get('rssi'))
        #(src_addr, ) = unpack('H', packet.get('source_addr'))
        #id = packet.get('id')
        #options = ord(packet.get('options'))

        
        status = pld.status
        type = pld.type
        data = pld.data
        if length == 0:
            return data
        else:
            return data[:min(length,len(data))]

# 需要导入模块: from xbee import XBee [as 别名]
# 或者: from xbee.XBee import wait_read_frame [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 wait_read_frame [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()