本文整理汇总了Python中xbee.XBee.halt方法的典型用法代码示例。如果您正苦于以下问题:Python XBee.halt方法的具体用法?Python XBee.halt怎么用?Python XBee.halt使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类xbee.XBee
的用法示例。
在下文中一共展示了XBee.halt方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: device
# 需要导入模块: 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
示例2: BasestationStream
# 需要导入模块: 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]})
示例3: BaseStation
# 需要导入模块: 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
示例4: BaseStation
# 需要导入模块: 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
示例5: loop
# 需要导入模块: 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()
示例6: BaseStation
# 需要导入模块: 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
示例7: Link
# 需要导入模块: 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()
示例8: XBeeManager
# 需要导入模块: 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()
示例9: __init__
# 需要导入模块: 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()
示例10: loop
# 需要导入模块: 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()
示例11: TestSuite
# 需要导入模块: 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()
示例12: BaseStation
# 需要导入模块: 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
#.........这里部分代码省略.........
示例13: XbeeChat
# 需要导入模块: 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))
#.........这里部分代码省略.........
示例14: ord
# 需要导入模块: 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
示例15: BasestationStream
# 需要导入模块: 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))