Python XBee.halt方法代码示例

# 需要导入模块: from xbee import XBee [as 别名]
# 或者: from xbee.XBee import halt [as 别名]
class Communicator:
    """Main communication class handles serial connection with the XBee module.

    Arguments:
        device -- Path to serial device (default: /dev/tty01)
        baudrate -- Serial baudrate (default: 9600)

    All received packet data is placed into the rx_queue.
    Transmission is handled by _packet_sender function.
    """
    def __init__(self, device='/dev/ttyO1', baudrate=9600):
        self.device    = device
        self.baudrate  = baudrate
        self.kill      = False

        self.rx_queue  = Queue()
        self.tx_queue  = Queue()

        self.serial    = Serial(self.device, self.baudrate)
        self.xbee      = XBee(self.serial, callback=self._packet_handler)

        self.tx_thread = Thread(target=self._packet_sender, args=())
        self.tx_thread.daemon = True
        self.tx_thread.start()

    def _packet_handler(self, data):
        """Internal serial callback adds data to rx_queue. No return."""
        self.rx_queue.put(data)

    def _packet_sender(self):
        """Internal threaded packet transmission loop.

        Reads outgoing packets from tx_queue and sends them over serial.
        """
        while True:
            if self.kill:
                exit(1)
            packet = self.tx_queue.get()
            self.tx_queue.task_done()

            if len(packet) > 100:
                WARN("Trying to send too large of a packet: %d" % len(packet))
                continue
            self.xbee.tx(dest_addr=packet[:2], data=packet[2:])

    def send(self, data):
        """Add data packet to transmission queue. No return.

        Packet data must be properly formated.
        [2 byte dst_addr][payload]
        """
        self.tx_queue.put(data)

    def close(self):
        """Cleanup communication pipes and threads. No return."""
        self.xbee.halt()
        self.serial.close()
        self.kill = True

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

#.........这里部分代码省略.........
		if callback:
			self.xbee = XBee(self.port, callback=callback, escaped=False)
			self.api = True
		else:
			self.api = False

	def set_callback(self, callback):
		if self.api:
			self._close_xbee()
			self.xbee = XBee(self.port, callback=callback)

	def send_message(self, msg):
		"""Send message

		Transmit a message with given parameters through the link.

		"""
		# Convert message
		string = str(msg)
		# Write serial
		if self.api:
			self.__send_packet(string, msg.to_id)
		else:
			self.__send_string(string)
		

	def __send_string(self, string):
		"""Send String

		Write *string* into the associated port.

		"""
		# Try to write string
		try:
			num_bytes = self.port.write(string)
		# Catch timeout
		except serial.SerialTimeoutException:
			print 'Error: timeout writing to port.'
		# Check if expected number of bytes were written
		else:
			if num_bytes != len(string):
				print 'Error: Mismatch in number of bytes written to port.'

	def __send_packet(self, string, to_id):
		"""Send Packet

		Write *string* into the associated port.

		"""
		# Try to write string
		try:
			addr = self.drone_addrs[to_id]
			self.xbee.tx(dest_addr=addr, data=string)
		# Catch timeout
		except serial.SerialTimeoutException:
			print 'Error: timeout writing to port.'


	def __read_string(self):
		"""Read String - Blocks!

		Reads and returns a string if one is recieved.

		"""
		string = self.port.readline()
		return string

	def read_message(self):
		"""Read Message (for serial mode - Blocks!)

		Parses a string, if recieved, and returns a message.

		"""
		# Get string
		if self.api:
			return None
		else:
			string = self.__read_string()
			# Check for timeout
			if not string:
				return None
			msg = Message(string=string)
			return msg


	def close(self):
		"""Close

		Proper close method. must be called manually.

		"""
		self._close_xbee()
		self._close_port()

	def _close_xbee(self):
		if self.api:
			self.xbee.halt()

	def _close_port(self):
		self.port.close()

# 需要导入模块: from xbee import XBee [as 别名]
# 或者: from xbee.XBee import halt [as 别名]
class XBeeManager(threading.Thread):

    def __init__(self, com, baud):
        threading.Thread.__init__(self)
        self.initialized = False
        self.running = False
        self.tx_fifo = Queue(100)
        self.rx_fifo = Queue(100)
        self.ser = None
        self.xb = None
        try:
            self.ser = Serial(port = com, baudrate = baud)
            self.xb = XBee(self.ser, self._rx_callback)
        except Exception as e:
            print "Exception in XBeeManager initialization:"
            print e
            self._cleanup()
            return     
        self.initialized = True   

    def run(self):
        if not self.initialized:
            return
        self.running = True
        while self.running:        
            try:
                (dest, packet) = self.tx_fifo.get(False, 1.0) # 1 second timeout
                self.xb.tx(dest_addr = dest, data = packet)
            except Empty:
                pass
            except Exception as e:
                print "Exception in XBeeManager main loop:"
                print e
                break
        
        self._cleanup()
        print "XBee Manager has terminated."            

    def isInitialized(self):
        return self.initialized

    def setAddress(self, addr, pan, chan):
        if not self.initialized:
            print "Cannot set address - module not initialized"
            return
        print "Setting addr: " + hex(addr) + " pan: " + hex(pan) + "chan: " + hex(chan)
        self.xb.at(command = 'MY', parameter = pack('>H', addr))
        self.xb.at(command = 'ID', parameter = pack('>H', pan))
        self.xb.at(command = 'CH', parameter = pack('>H', chan))

    def putTxPacket(self, dest, packet):
        if not self.initialized:
            return
        
        try:
            self.tx_fifo.put_nowait((dest, packet))
        except Full:
            print "XB transmit buffer full!"

    def hasRxPacket(self):
        if not self.initialized:
            return False
        return not self.rx_fifo.empty()

    def getRxPacket(self, packet):
        if not self.initialized:
            return None
        try:
            packet = self.rx_fifo.get_nowait()
        except Empty:
            packet = None
        return packet

    def close(self):
        self.running = False

    def _rx_callback(self, packet):     
        try:   
            self.rx_fifo.put_nowait(packet)
        except Full:
            print "XB receive buffer full!"

    def _cleanup(self):
        if self.xb != None:
            print "Halting XBee."
            self.xb.halt()
        if self.ser != None:
            print "Closing COM port."
            self.ser.close()

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

#.........这里部分代码省略.........

    def do_associate(self, frame):
        if frame["status"] == '\x00':
            if self.state is XOMBIEStream.ASSOCIATING:
                self.state = XOMBIEStream.ASSOCIATED
                self.logger.info("Now associated with XBee")
        else:
            self.state = XOMBIEStream.UNASSOCIATED

    def process(self, frame):
        #print frame
        #print "\a"
        if frame["id"] == "rx_long_addr":
            alpha = 0.5
            rssi = -ord(frame["rssi"])
            if self.rssi_average is None:
                self.rssi_average = rssi
            else:
                self.rssi_average = self.rssi_average * (1-alpha) + rssi
            print "RSSI:" + str(rssi)
            self.last_received = datetime.datetime.utcnow()
            msg = frame["rf_data"]
            (source, ) = struct.unpack(">q", frame["source_addr"])
            if self.decoder.is_command(msg):
                try:
                    command = self.decoder.decode_command(msg)
                except ValueError as e:
                    self.logger.error("Error while decoding command packet: %s", e)
                    print frame
                    return
                if command[0] == 0x84:
                    self.logger.info("Got heartbeat request. Replying with heartbeat.")
                    if 0x84 not in self.command_callbacks or not self.command_callbacks[0x84]():
                        self.send_no_ack("\x85")
                    return
                elif command[0] == 0x85:
                    if 0x85 not in self.command_callbacks or not self.command_callbacks[0x85]():
                        pass  
                elif command[0] == 0x82:
                    self.state = XOMBIEStream.ASSOCIATING
                    self.rel_start = command[1][0]
                    self.abs_start = datetime.datetime.utcnow()
                    self.logger.info("Received handshake reply from XBee address=%#x synchronized at BRAIN time=%s, Laptop time=%s",
                                     source,
                                     self.rel_start,
                                     self.abs_start.strftime("%Y-%m-%d %H:%M:%S"))
                    if 0x82 not in self.command_callbacks or not self.command_callbacks[0x82]():
                        self.send_handshake3()
                elif command[0] in self.command_callbacks:
                    self.command_callbacks[command[0]](*command[1:])
                else:
                    self.logger.warning("Got irrelevant command message %#x", command[0])
                    pass
            else:
                if self.state is XOMBIEStream.UNASSOCIATED:
                    self.send_handshake1()
                elif self.state in (XOMBIEStream.ASSOCIATING, XOMBIEStream.ASSOCIATED):
                    if self.state is XOMBIEStream.ASSOCIATING:
                        self.state = XOMBIEStream.ASSOCIATED
                        self.logger.info("Now associated with XBee address=%#x", source)
                    try:
                        messages = list(self.decoder.decode_multi(msg))
                    except ValueError as e:
                        self.logger.error("Error while decoding data packet: %s", e)
                        self.logger.error(" ".join([str(hex(ord(b))) for b in msg]))
                        return
                    for (offset, id_, desc, data) in messages:
                        dt = datetime.timedelta(seconds=(offset - self.rel_start)/1000.0)
                        for msg_desc, datum in zip(desc["messages"], data):
                            ident = "%#x:%s" % (id_, msg_desc[0])
                            self.put_data(ident, (self.abs_start+dt, datum), msg_desc)
                            self.msg_queue.put((id_, msg_desc[0], self.abs_start+dt, datum))
                            #self.logger.info("Got packet %s = %s", ident, datum)
        elif frame["id"] == "tx_status" or "frame_id" in frame:
            (frame_id,) = struct.unpack(">B", frame["frame_id"])
            if frame_id in self.frame_cache:
                data, callback = self.frame_cache[frame_id]
                if callback:
                    try:
                        callback(frame)
                    except:
                        traceback.print_exc()

    def put_data(self, identifier, datum, desc=None):
        if identifier not in self.data_table:
            self.data_table[identifier] = DataSource(identifier, desc)
        self.data_table[identifier].put(datum)

    def get_data(self, identifier):
        if identifier not in self.data_table:
            self.data_table[identifier] = DataSource(identifier)
        return self.data_table[identifier]

    def add_callback(self, id_, cb):
        self.command_callbacks[id_] = cb

    def close(self):
        "Shuts down the XBee processing thread and closes the serial port"
        self.xbee.halt()
        self.port.close()

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

#.........这里部分代码省略.........
            Turn on a motor.
        Parameters:
            motor_id    : The motor number to turn on
            time        : The amount of time to turn the motor on for (in
                          milliseconds)
            duty_cycle  : The duty cycle of the PWM signal used to control the
                          motor in -4000 < dc < 4000
            direction   : The direction to spin the motor. There are *three*
                          options for this parameter. 0 - reverse, 1 - forward,
                          2 high impedance motor controller output = braking
            return_emf  : Send the back emf readings over the radio channel.
        '''
        duration = 500; # time in milliseconds
        data_out = chr(kStatusUnused) + chr(kTestMotorCmd) + \
                   pack('3h', motor_id, duration, duty_cycle)
        print "testing motor " + str(motor_id)           
        if(self.check_conn()):
            self.radio.tx(dest_addr=self.dest_addr, data=data_out)
            time.sleep(1)
            
###########
    def test_sma(self, chan_id, time, duty_cycle):
        '''
        Description:
            Turn on an SMA
        Parameters:
            chan_id     : The SMA channel to turn on
            time        : The amount of time to turn the SMA on for (in
                          seconds)
            duty_cycle  : The duty cycle of the PWM signal used to control the
                          SMA in percent (0 - 100)
        '''

        if(duty_cycle < 0 or duty_cycle > 100):
            print("You entered an invalid duty cycle.")
            return

        data_out = chr(kStatusUnused) + chr(kTestSMACmd) + chr(chan_id) + \
                   chr(time) + chr(duty_cycle)

        if(self.check_conn()):
            self.radio.tx(dest_addr=self.dest_addr, data=data_out)


    def print_packet(self, packet):
        '''
        Description:
            Print the contents of a packet to the screen. This function
            will primarily be used for debugging purposes. May need to
            replace print with stdio or stderr to accommodate GUI test
            suite.
        '''
        if(packet is not None):
            print("Received the following: ")
            print("RSSI: " + str(ord(packet.get('rssi'))))
            (src_h, src_l) = unpack('cc', packet.get('source_addr'))
            print("Source Address: 0x%.2X 0x%.2X" % (ord(src_h),
                  ord(src_l)))
            print("ID: " + (packet.get('id')))
            print("Options: " + str(ord(packet.get('options'))))
            rf_data = packet.get('rf_data')
            print("Status Field: " + str(ord(rf_data[0])))
            print("Type Field: " + str(ord(rf_data[1])))
  #          print("Payload Data: " + ''.join([str(ord(i)) for i in rf_data[2:]]))
            print "Payload Data: " 
            print map(ord,rf_data[2:])
  #          print("Payload" + rf_data[2:])
            print map(str,rf_data[2:])
  #          print(map(chr,rf_data))

# gyro packet :  int xl_data[3]; int gyro_data[3]; int temp;
    def print_gyro(self, packet):
        rf_data = packet.get('rf_data')
#        print "length of data " + str(len(rf_data[2:]))
        print "xl data:" + str(map(hex,unpack('3h',rf_data[2:8])))
        print "gyro data:" + str(map(hex,unpack('3h',rf_data[8:14])))
        print "temperature:" + str(map(hex,unpack('1h',rf_data[14:16])))
#        print map(hex,unpack('7h',rf_data[2:]))

# Austria Microsystems Hall angle sensor packet:
# int pos; long oticks; int calibPOS; int offset;
    def print_hall(self,packet):
        rf_data = packet.get('rf_data')
        index = 0
        for i in range(1,3):
            print "Hall encoder:" + str(i-1)
            print "position" + str(map(hex,unpack('1h',rf_data[index+2:index+4]))) + \
                " revolutions" + str(map(hex,unpack('1i',rf_data[index+4:index+8])))
            print "cal. pos and offset" + \
                  str(map(hex,unpack('2h',rf_data[index+8:index+12])))
            index = index + 10
        print " "

    def __del__(self):
        '''
        Description:
            Clean up the connection when the object is deleted.
        '''
        self.radio.halt()
        self.conn.close()

# 需要导入模块: from xbee import XBee [as 别名]
# 或者: from xbee.XBee import halt [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 halt [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 halt [as 别名]
	sensorIdHex = dataPacket["source_addr"]

	# # Get the actual sensor id, and make sure that there is data to grab
	sensorId = ord(sensorIdHex[0]) * 256 + ord(sensorIdHex[1])

	return sensorId


xbee = XBee(ser, callback=message_receieved)
while True:
	try:
		time.sleep(.1)
	except KeyboardInterrupt:
		break
	
xbee.halt()











"""
DEPREICATED FUNCTIONS:
small reason for deprication is given on each function
Most of them are a result of the parking project no longer being able to have a pi and fio at each sensor

# 需要导入模块: from xbee import XBee [as 别名]
# 或者: from xbee.XBee import halt [as 别名]
class BasestationStream(threading.Thread):
  def __init__(self, port='COM1', baudrate=230400, addr=0x2071, timeout=-1, 
      timeoutFunction = None):
      
    threading.Thread.__init__(self)
    self.daemon = True
    
    try:
      self.ser = serial.Serial(port, baudrate, timeout=3, rtscts=0)
      
    except serial.serialutil.SerialException:
      print "Could not open serial port:%d"
      sys.exit()
    
    self.addr = addr
    
    self.timeout = timeout
    self.last_time = -1
    self.timeoutFunction = timeoutFunction
    self.xb = XBee(self.ser, callback = self.receiveCallback)
    self.send_queue = Queue.Queue()
    self.receive_queue = Queue.Queue()
    
  def run(self):
    while True:
      if self.last_time != -1 and self.timeout != -1 \
          and self.timeoutFunction is not None \
          and (time.time() - self.last_time) > self.timeout:
        self.timeoutFunction()
        
      if not self.send_queue.empty():
        entry = self.send_queue.get()
        
        if entry[0] == 'packet':
          pkt = entry[1]
          print pkt
          #self.xb.tx(dest_addr = pack('>h',pkt.dest_addr), data = pkt.payload)
          self.xb.tx(dest_addr = pack('>h',pkt.dest_addr), data = (chr(0) + chr(0x88) + ''.join(pack('h',0))))
        
        elif entry[0] == 'quit':
          self.xb.halt()
          self.ser.close()
          sys.exit()
    
  def get(self):
    if not self.receive_queue.empty():
      return self.receive_queue.get()
    else:
      return None
  
  def put(self,entry):
    self.send_queue.put(entry)
    
  def receiveCallback(self,xbee_data):
    self.last_time = time.time()
    pkt = Packet(dest_addr=self.addr, time=self.last_time,
      payload=xbee_data.get('rf_data'))
    self.receive_queue.put(('packet',pkt))
  
  def sendPacket(self,pkt):
    self.send_queue.put(('packet',pkt))