def receive_xbee_pin():
PORT = '/dev/ttyUSB4'
BAUD_RATE = 9600
serial_port = serial.Serial(PORT, BAUD_RATE)
def print_data(data):
"""
This method is called whenever data is received
from the associated XBee device. Its first and
only argument is the data contained within the
frame.
"""
print(data)
ser.write(b'hello')
xbee = XBee(serial_port, callback=print_data)
while True:
try:
time.sleep(0.01)
except KeyboardInterrupt:
break
xbee.halt()
serial_port.close()
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='******')
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()
def programGun(gunList, code, ng=False):
"""send code string to list of guns; code can be a list -- if so, send all strings
gunList is a list of guns to send code to; if gunList is empty, send to all guns
ng = false; if true, send new game"""
ser = serial.Serial('/dev/tty.usbserial-DA01MHIK', 19200)
xbee = XBee(ser)
pref = '\x40\x06\x00'
if len(gunList) == 0: gunList = range(1, 27)
dest = ['\x00' + str(unichr(int(ii))) for ii in gunList]
if type(code) != list: code = [code]
for ii in range(3):
for c1 in code:
for gun in dest:
x = xbee.send('tx', dest_addr=gun, data=pref)
x = xbee.send('tx', dest_addr=gun, data=c1)
time.sleep(0.5)
print 'sent: %i' % (ii + 1)
if ng:
time.sleep(0.6)
newGame(gunList)
def xbee_message():
xbee_msg = rospy.Publisher('xbee_message', String, queue_size=10)
rospy.init_node('xbee', anonymous=False)
rate = rospy.Rate(1000)
# try to open serial ports
try:
ser = serial.Serial(constants.XBEE_PORT, 115200, timeout=.1)
except:
rospy.logerr("Failed to open %s", constants.XBEE_PORT)
i = 0
while not rospy.is_shutdown():
if ser != 0:
#read xbee data
# Use an XBee 802.15.4 device
xbee = XBee(ser)
msg = xbee.wait_read_frame()
i = i + 1
print(i)
#rospy.loginfo(msg['rf_data'])
xbee_msg.publish(msg['rf_data'])
rate.sleep()
def __init__(self, known=False, file_name=False):
self.width = 2.0
self.height = 1.2
# set up walls, putting top left point first
self.walls = []
self.walls.append(E160_wall([-0.5, 0.5, -0.5, -0.5], "vertical"))
self.walls.append(E160_wall([0.5, 0.5, 0.5, -0.5], "vertical"))
self.walls.append(E160_wall([-0.5, 0.5, 0.5, 0.5], "horizontal"))
# self.walls.append(E160_wall([0.5, -0.5, 1, -0.5],"horizontal"))
# self.walls.append(E160_wall([-0.5, -0.5, 0.5, -1],"horizontal"))
# self.walls.append(E160_wall([-0.5, -0.5, 0.0, -1.0],"vertical"))
# create vars for hardware vs simulation
self.robot_mode = "SIMULATION MODE" #"SIMULATION MODE" or "HARDWARE MODE"
self.control_mode = "MANUAL CONTROL MODE"
# setup xbee communication
if (self.robot_mode == "HARDWARE MODE"):
self.serial_port = serial.Serial('/dev/ttyUSB0', 9600)
print " Setting up serial port"
try:
self.xbee = XBee(self.serial_port)
except:
print("Couldn't find the serial port")
# Setup the robots
self.num_robots = 1
self.robots = []
for i in range(0, self.num_robots):
# TODO: assign different address to each bot
r = E160_robot(self, '\x00\x0C', i, known, file_name)
self.robots.append(r)
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'
def __init__(self,
sinks=None,
callbacks=None,
port='COM5',
baudrate=57600,
addr='\x30\x02',
timeout=-1,
timeoutFunction=None):
threading.Thread.__init__(self)
self.daemon = True
try:
self.ser = serial.Serial(port, baudrate, timeout=3, rtscts=0)
print "Serial Port Set Up"
except serial.serialutil.SerialException:
print "Could not open serial port:%d"
self.addr = addr
self.dispatcher = AsynchDispatch(sinks=sinks, callbacks=callbacks)
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()
self.start()
def __init__(self, com=USB_PORT, baud=9600):
"""Creates an instance of XBeeComm class
Arguments:
com (str): directory of the connected port
baud (int): baud rate
"""
self.xbee = XBee(serial.Serial(com, baud))
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()
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 __init__(self):
log.msg("Initializing XBee port...")
self._ser = serial.Serial(settings.SERIAL_PORT,
settings.SERIAL_SPEED,
timeout=settings.SERIAL_TIMEOUT)
self._xbee = XBee(self._ser, api_mode=2)
reactor.addSystemEventTrigger('before', 'shutdown', self._xbee.halt)
reactor.callLater(0, self._loop)
def __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 __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()
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]})
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
class E160_environment:
def __init__(self):
self.width = 2.0
self.height = 1.2
# set up walls, putting top left point first
self.walls = []
self.walls.append(E160_wall([-0.5, 0.5, -0.5, -0.5], "vertical"))
self.walls.append(E160_wall([0.5, 0.5, 0.5, -0.5], "vertical"))
self.walls.append(E160_wall([-0.5, 0.5, 0.5, 0.5], "horizontal"))
#self.walls.append(E160_wall([-0.4, -0.4, -0.4, 0.4],"vertical"))
#self.walls.append(E160_wall([0.455, 0.4, -0.455, 0.4],"horizontal"))
#self.walls.append(E160_wall([0.455, -0.4, -0.455, -0.4],"horizontal"))
# self.walls.append(E160_wall([0.5, -0.5, 1, -0.5],"horizontal"))
# self.walls.append(E160_wall([-0.5, -0.5, 0.5, -1],"horizontal"))
# self.walls.append(E160_wall([-0.5, -0.5, 0.0, -1.0],"vertical"))
# create vars for hardware vs simulation
self.robot_mode = "SIMULATION MODE" #"SIMULATION MODE" or "HARDWARE MODE"
self.control_mode = "AUTONOMOUS CONTROL MODE"
# setup xbee communication
if (self.robot_mode == "HARDWARE MODE"):
self.serial_port = serial.Serial('COM5', 9600)
print " Setting up serial port"
try:
self.xbee = XBee(self.serial_port)
except:
print("Couldn't find the serial port")
# Setup the robots
self.num_robots = 1
self.robots = []
for i in range(0, self.num_robots):
# TODO: assign different address to each bot
r = E160_robot(self, '\x00\x0C', i)
self.robots.append(r)
def update_robots(self, deltaT):
# loop over all robots and update their state
for r in self.robots:
# set the control actuation
r.update(deltaT)
def log_data(self):
# loop over all robots and update their state
for r in self.robots:
r.log_data()
def quit(self):
self.xbee.halt()
self.serial.close()
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
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
def get_xbee(port):
def print_data(data):
print "%s: %s" % (port, repr(data))
serial_port = serial.Serial(XBEES[port]['port'], 9600)
xbee = XBee(serial_port)
xbee.id = XBEES[port]['id']
return (xbee, serial_port)
def get_xbee(port):
def print_data(data):
print "%s: %s" % (port, repr(data))
serial_port = serial.Serial(XBEES[port]['port'], 9600)
xbee = XBee(serial_port)
xbee.id = XBEES[port]['id']
return (xbee, serial_port)
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
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
def getTrial():
timeOut = 60
counterLimit = 50
ser = Serial(PORT, BAUD, timeout=1)
xbee = XBee(ser)
# Send Ready messages
xbee.tx(dest_addr='\x00\x01', data=start_ready_message)
# Wait for start line crossed
beginTime = time.time()
while not ser.inWaiting(): #check for no response and end if no response
endTime = time.time()
if (endTime-beginTime > timeOut):
return None
startMessage = xbee.wait_read_frame()["rf_data"].decode('utf8')
startTime = time.time()
counter = 0
while(startMessage != start_line_crossed_message):
if (counter > counterLimit): #Try for the correct message counterLimit times
return None
beginTime = time.time()
while not ser.inWaiting(): #check for no response and end if no response
endTime = time.time()
if (endTime-beginTime > timeOut):
return None
startMessage = xbee.wait_read_frame()["rf_data"].decode('utf8')
startTime = time.time()
counter += 1
xbee.tx(dest_addr='\x00\x01', data=finish_ready_message)
# Wait for finish line crossed
beginTime = time.time()
while not ser.inWaiting(): #check for no response and end if no response
endTime = time.time()
if (endTime-beginTime > timeOut):
return None
finishMessage = xbee.wait_read_frame()["rf_data"].decode('utf8')
finishTime = time.time()
counter = 0
while(finishMessage != finish_line_crossed_message):
if (counter > counterLimit): #Try for the correct message counterLimit times
return None
beginTime = time.time()
while not ser.inWaiting(): #check for no response and end if no response
endTime = time.time()
if (endTime-beginTime > timeOut):
return None
finishMessage = xbee.wait_read_frame()["rf_data"].decode('utf8')
finishTime = time.time()
counter += 1
trialTime = finishTime - startTime
return trialTime
def __init__(self, maze=[], corners=[], pixel_pos=(), file_name=False):
self.width = 2.5
self.height = 2.0
self.cell_width = 0.45
self.cell_height = 0.4
self.top_left_corner = corners[0]
self.bottom_right_corner = corners[3]
self.pixel_width = self.bottom_right_corner[0] - self.top_left_corner[0]
self.pixel_height = self.bottom_right_corner[1] - self.top_left_corner[
1]
self.maze = E160_maze(maze)
# set up walls, putting top left point first
self.walls = []
for start, end, slope in self.maze.walls:
self.walls.append(
E160_wall([
(-self.width / 2 + 0.2) - self.top_left_corner[0] *
(self.width / self.pixel_width) +
start[0] * self.cell_width,
(self.height / 2 - 0.2) + self.top_left_corner[1] *
(self.width / self.pixel_width) +
start[1] * self.cell_height,
(-self.width / 2 + 0.2) - self.top_left_corner[0] *
(self.width / self.pixel_width) + end[0] * self.cell_width,
(self.height / 2 - 0.2) + self.top_left_corner[1] *
(self.width / self.pixel_width) + end[1] * self.cell_height
], slope))
# create vars for hardware vs simulation
self.robot_mode = "HARDWARE MODE" #"SIMULATION MODE" or "HARDWARE MODE"
self.control_mode = "AUTONOMOUS CONTROL MODE"
self.track_mode = "PATH MODE" #"POINT MODE" or "PATH MODE"
# setup xbee communication
if (self.robot_mode == "HARDWARE MODE"):
self.serial_port = serial.Serial('/dev/ttyUSB0', 9600)
print " Setting up serial port"
try:
self.xbee = XBee(self.serial_port)
except:
print("Couldn't find the serial port")
# Setup the robots
self.num_robots = 1
self.robots = []
for i in range(0, self.num_robots):
botActualPos = self.get_pos_from_pixel_pos(pixel_pos)
# TODO: assign different address to each bot
r = E160_robot(self, '\x00\x0C', i, botActualPos, file_name)
self.robots.append(r)
def connect(self):
"""
Creates an Xbee instance
"""
try:
self.log(logging.INFO, "Connecting to Xbee")
self.xbee = XBee(self.serial, callback=self.process)
except:
return False
return True
def _send_command(self, data): ser = Serial(SERIAL_PORT, BAUD_RATE) xbee = XBee(ser) try: xbee.tx(dest_addr=PEGGY_ADDRESS, data=data) ser.close() return True except: ser.close() return False
def main():
ser = serial.Serial('', 9600)
xbee = XBee(ser)
while True:
try:
response = xbee.wait_read_frame()
print response
except KeyboardInterrupt:
break
ser.close()
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 setup(self, port, baud=115200):
try:
self.serial = Serial(port, baud, writeTimeout=0)
self.xbee = XBee(self.serial)
print("Hermes is set up")
return True
except SerialException:
print("In Hermes set up: Error opening xBee connection")
return False
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 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()
def __init__(self,port,timeouttime): 'initialise xbee manager' try: self.ser = serial.Serial(port,timeout=1) self.xbee = XBee(self.ser) self.timeout = timeouttime except Exception as inst: print type(inst) # the exception instance print inst.args # arguments stored in .args print inst # __str__ allows args to be printed directly print "ooops something went wrong setting up"
def communication(inp):
# initialising a serial port object
# fist parameter is com port
# second parameter is baud rate
ser_port = serial.Serial('COM3', 9600)
# initialising an xbee object at the serial port
xbee = XBee(ser_port)
# transmit packet in API mode
# first parameter is the 16 bit destination address of the receiver xbee
# second parameter is the data to be transmitted
xbee.tx(dest_addr='\x00\x01', data=inp)
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=False)
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)),
('MM', "\x02"),
('MY', struct.pack(">H", self.address)),
("CH", struct.pack(">B", self.channel)),
("ID", struct.pack(">H", self.panid)),
("D7", "\x00"),
("D6", "\x00"),
("D5", "\x00"),
("IU", "\x00"),
("P0", "\x01"),
("P1", "\x00"),
("RN", "\x01"), # random delay slot backoff in CSMA-CA
("WR", None)
])
except Exception as x:
# if we fail at this point, we have to shutdown, then raise the exception
self.log.info("shutting down")
self.xbee.halt()
self.ser.close()
raise x
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
def __init__(self, inpq, outpq):
threading.Thread.__init__(self)
# Common variables
self.inpq = inpq
self.outpq = outpq
self.run_flag = 1
self.exit_flag = 0
# We need a timer to keep track of led blinking
self.blinkFastTimer = time.time()
self.blinkSlowTimer = time.time()
# This timer will switch this boolean
self.blinkFastState = False
self.blinkSlowState = False
# We need registers to debounce button presses
self.prevIn = {}
#status dictionaries
self.statDict = {}
# Status init
for key, value in ledDict.iteritems():
# Off On BlinkFast BlinkSlow
self.statDict[value] = "Off"
# BCM init
GPIO.setmode(GPIO.BOARD)
for key, value in ledDict.iteritems():
GPIO.setup(value, GPIO.OUT)
GPIO.output(value, False)
for key, value in inDict.iteritems():
GPIO.setup(key, GPIO.IN, pull_up_down=GPIO.PUD_UP)
self.prevIn[key] = True
# Wireless init:
UART_0 = 18
UART_1 = 22
GPIO.setmode(GPIO.BOARD) # Initialize GPIO
GPIO.setup(UART_0, GPIO.OUT) # S0
GPIO.setup(UART_1, GPIO.OUT)
GPIO.output(UART_0, True)
GPIO.output(UART_1, False)
self.serial_port = serial.Serial('/dev/ttyS0', 9600)
self.xbee = XBee(self.serial_port)
self.xbee.send('at', frame_id='A', command='NI')
x = self.xbee.wait_read_frame()
print x
self.name = x['parameter']
self.xbee = XBee(self.serial_port, callback=self.receive_data)
def __init__(self):
# Iniitalize a new serial port communicating on block device /dev/ttyS0 (GPIO serial on the RPi 3)
self.serial = serial.Serial('/dev/ttyS0', 9600)
# Initialize an XBee object from the XBee library
# Pass the serial object to the XBee object
# Assign the dispatch method to be called when a new frame is received
# Configure the XBee library to escape characters to match the AP setting in the XBee
self.xbee = XBee(self.serial, callback=self.dispatch, escaped=True)
# Initialize an internal list to store all of the callback objects to be called when data is received
self.callbacks = list()
def xbee_ping():
port = serial.Serial('/dev/ttyUSB0', 9600, timeout=2)
xbee = XBee(port, callback=handle_message)
msg = '0\n'
drone_addrs = [
'\x00\x02',
'\x00\x03'
]
while True:
for addr in drone_addrs:
xbee.tx(dest_addr=addr, data=msg)
print 'Sent {0} to drones {1}'.format(msg, drone_addrs)
time.sleep(1)
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 main():
try:
ser = serial.Serial('/dev/tty.usbserial-AL01T2SX', 9600)
xbee = XBee(ser)
xbee.send('at', frame_id='A', command='DH')
response = xbee.wait_read_frame()
except KeyboardInterrupt:
pass
finally:
ser.close()
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()
def main():
parser = argparse.ArgumentParser("test XBEE")
parser.add_argument('--xbee-port', type=str, default='/dev/ttyUSB4')
args = parser.parse_args()
ser = serial.Serial(args.xbee_port, 57600)
xbee = XBee(ser)
while True:
try:
response = xbee.wait_read_frame()
print(str(response['rf_data']))
except Exception:
pass
def licht_an():
"""
Get module status, for the light is to return the status of the light
"""
ser = serial.Serial('/dev/ttyUSB0', 9600)
xbee = XBee(ser)
xbee.send('remote_at',
frame_id='1',
dest_addr_long='\x00\x13\xA2\x00\x40\xAF\xBB\x52',
dest_addr='\xFF\xFE',
options='\x02',
command='D0',
parameter='\x05')
return "1"
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()
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
def connect(self):
"""
Creates an Xbee instance
"""
try:
self.log(logging.INFO, "Connecting to Xbee")
if self.radio_type == 'IEEE':
self.xbee = XBee(self.serial, callback=self.process, escaped=True)
elif self.radio_type == 'DigiMesh':
self.xbee = DigiMesh(self.serial, callback = self.process, escaped = True)
else:
self.xbee = XBee(self.serial, callback=self.process, escaped=True)
except:
return False
return True
def __init__(self, callback=None, read_timeout=None, write_timeout=None):
self.port = serial.Serial('/dev/ttyUSB0', 9600, timeout=read_timeout, writeTimeout=write_timeout)
if callback:
self.xbee = XBee(self.port, callback=callback, escaped=False)
self.api = True
else:
self.api = False
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.startReceive = True
self.sendMessage = self.id+'PKT'
self.buffer = ['0']
self.newest_byte = '0'
self.ser.flush()
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)
class XBeeDataPublisher(object):
__metaclass__ = ABCMeta # ABstract Class
def __init__(self, pub_data):
port = rospy.get_param('~xbee_port', default='/dev/ttyUSB0')
baudrate = rospy.get_param('~xbee_baudrate', default=9600)
self._xbee = XBee(serial.Serial(port, baudrate))
self._pub_data = pub_data
self._data_pub = rospy.Publisher(DEFAULT_XBEE_DATA_PUB_TOPIC,
self._pub_data.__class__,
queue_size=1)
self.is_activated = False
def activate(self):
self.is_activated = True
@abstractmethod
def _convert_xbee_data(self, binary_data):
self._pub_data = binary_data
def publish_data(self):
if not self.is_activated:
self.activate()
self._convert_xbee_data(self._xbee._wait_for_frame())
# self._convert_xbee_data(self._xbee.wait_read_frame()) is not available for current XBee
self._data_pub.publish(self._pub_data)
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()
def __init__(self, dev_name, baud_rate=230400, dest_addr="\xff\xff"):
"""
Description:
Initiate the 802.15.4 connection and configure the target.
Class must be instantiated with a connection name. On Windows this is
typically of the form "COMX". On Mac, the serial device connection
string is typically '/dev/tty.DEVICE_NAME-SPP-(1)' where the number at
the end is optional depending on the version of the OS.
Inputs:
dev_name: The device name to connect to. Examples are COM5 or
/dev/tty.usbserial.
print ord(datum)
"""
if dev_name == "" or dev_name == None:
print "You did not instantiate the class with a device name " + "(eg. COM5, /dev/tty.usbserial)."
sys.exit()
if dest_addr == "\xff\xff":
print "Destination address is set to broadcast. You will " + "interfere with other 802.15.4 devices in the area." + " To avoid interfering, instantiate the class with a " + "destination address explicitly."
self.dest_addr = dest_addr
self.last_packet = None
try:
self.conn = Serial(dev_name, baudrate=baud_rate, rtscts=True)
if self.conn.isOpen():
self.radio = XBee(self.conn, callback=self.receive)
pass
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
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 __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()
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)
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))]
def init_comm( self ):
print( "initialising communication through serial port")
self.tapped_ser = self.serial
if self.tapSerial:
self.tapped_ser = TappedSerial( self.serial )
self.dispatch = Dispatch( self.tapped_ser )
self.register_callbacks()
self.xbee = XBee( self.tapped_ser, callback=self.dispatch.dispatch, escaped=True)
self.xbee.name = "xbee-thread"
def connect(self):
"""
Creates an Xbee instance
"""
try:
self.log(logging.INFO, "Connecting to Xbee")
self.xbee = XBee(self.serial, callback=self.process)
except:
return False
return True
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__()
