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
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 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
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 __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__()