def hiddenNodediscovery(): comPortList = getActiveComPort() if comPortList: comPort = comPortList[0].get('name') timeOut = int(comPortList[0].get('timeout')) baudRate = int(comPortList[0].get('baudrate')) print "Hidden Discovery" try: ser = serial.Serial(comPort, baudRate, timeout=timeOut) print "porta e otworen", ser.isOpen() xbee = ZigBee(ser,escaped=True) xbee.at(command='ND') response = {'':''} while response <> {}: response = xbee.wait_read_frame() if response: print response else: text = "Xbee: Timeout during node discovery operation!" response = {} print text except serial.SerialException as ex: text = "Exception: " + ex.__str__() return text else: ser.close()
class RadioHandler: ''' This class is responsible for reading data from a xBee conneced via serial port, formatting the data in a python object and calling a GUI callback with the formatted data. If fakeData is True, serialPort is ignored and fake data is generated ''' def __init__(self, serialPort, callback, fakeData=False): self.callback = callback self.fake = fakeData if self.fake: self.interval = 0.5 #Adjust theese numbers to change fake data generation self.speed = 20 self.height = 0 self.stopFlag = Event() fakeThread = Timer(self.stopFlag, self._fakeCallback, self.interval) fakeThread.start() else: self.port = serial.Serial(serialPort, BAUD_RATE) self.xbee = ZigBee(self.port, callback=self._recvCallback) def _fakeCallback(self): ''' Generates fake data and sends them to GUI, called from timer thread ''' data = {} data['source'] = '--FAKE----TEST--' data['time'] = datetime.now() data['IAS'] = self.speed data['height'] = self.height self.speed += 2 self.height += 10 # Turns a dictionary into a namespace self.callback(SimpleNamespace(**data)) def _recvCallback(self, rawData): ''' Reads data from xBee, formats the data and calls GUI ''' try: source = rawData['source_addr_long'] payload = json.loads(rawData['rf_data'].decode('ascii')) # This is here to explicitly decouple JSON naming convention # from python internal variable names data = {} data['source'] = binascii.hexlify(source).decode('ascii').upper() data['time'] = datetime.now() data['IAS'] = payload.pop('IAS') data['height'] = payload.pop('HEI') except Exception as e: print("Could not parse frame:") print(e) # Turns a dictionary into a namespace self.callback(SimpleNamespace(**data)) def halt(self): if self.fake: self.stopFlag.set() else: self.xbee.halt() self.port.close()
def __init__(self, path, baud=9600, callback=None, data_only=False): self.path = path self.baud = baud self.delivery = Delivery(chunk_limit=25) if callback is None: self.callback = self.__queuedCallback else: self.callback = callback try: self.ser = serial.Serial(path, baudrate=baud) except: print "serial failed" exit() try: self.xb = ZigBee(self.ser, callback=self.callback) except: print "xb initialization failed" self.ser.close() exit() self.queue = Queue.Queue() self.queueAT = Queue.Queue() #Mailbox specifically for AT Responses self.data_only = data_only
def hiddenXbeePin(xbeeRemAddr, xbeePin, xbeePinState): "Manipulate XBee pins. Input: xbeeRemAddr, xbeePin, xbeePinState. Ex: xbee_pin('0013A200406B5174'.decode('hex'),'D0','ON')" comPortList = getActiveComPort() if comPortList: comPort = comPortList[0].get('name') timeOut = int(comPortList[0].get('timeout')) baudRate = int(comPortList[0].get('baudrate')) count = 0 try: ser = serial.Serial(comPort, baudRate, timeout=timeOut) xbee = ZigBee(ser,escaped=True) if xbeePinState == 'ON': xbeePinStateHex = '\x05' if xbeePinState == 'OFF': xbeePinStateHex = '\x04' try: xbee.remote_at(dest_addr_long=xbeeRemAddr,command=xbeePin,parameter=xbeePinStateHex) finally: return 1 except serial.SerialException as ex: text = "Exception is: " + ex.__str__() return 0 else: xbee.halt() ser.close()
def hiddenNodediscovery(): comPortList = getActiveComPort() if comPortList: comPort = comPortList[0].get('name') timeOut = int(comPortList[0].get('timeout')) baudRate = int(comPortList[0].get('baudrate')) print "Hidden Discovery" try: ser = serial.Serial(comPort, baudRate, timeout=timeOut) print "porta e otworen", ser.isOpen() xbee = ZigBee(ser, escaped=True) xbee.at(command='ND') response = {'': ''} while response <> {}: response = xbee.wait_read_frame() if response: print response else: text = "Xbee: Timeout during node discovery operation!" response = {} print text except serial.SerialException as ex: text = "Exception: " + ex.__str__() return text else: ser.close()
def get_RSSI(iteration): comm = serial.Serial('/dev/ttyUSB0', 9600) xbee_conn = ZigBee(comm) rssi = 0 rssi_list = [] counter = 0 while counter < iteration: try: packet = xbee_conn.wait_read_frame() xbee_conn.at(command=b'DB') if 'parameter' in packet: rssi_list.append(packet['parameter'][0]) counter += 1 sleep(0.1) except KeyboardInterrupt: break comm.close() if len(rssi_list) > 0: rssi = max(set(rssi_list), key=rssi_list.count) print(rssi) return int(rssi)
def main(): args = setup_argparser() #setup serial port ser = serial.Serial(args.port, 9600) xbee = ZigBee(ser, escaped=True) exit_code = 0 #send force sample command IS xbee.remote_at(dest_addr_long=to_hex(args.device), command='IS', frame_id=cmd_id) try: response = xbee.wait_read_frame() #ack received if response['status'] == '\x00' and response['frame_id'] == cmd_id: try: print response['parameter'][0][response_lookup[args.gpio]] #desired value not included in response except KeyError: print "No sample for {0} received. The PIN may not be properly configured. For ADC select Mode 2 (analog input)".format(args.gpio) exit_code = -1 #error message received else: print "Command was not successful: ", status_help[response['status']] exit_code = ord(response['status']) except KeyboardInterrupt: print "cancel script" #clean up ser.close() exit(exit_code)
def main(argv=sys.argv[1:]): parser = argparse.ArgumentParser( description="Continuously read sensor data from XBee and write to " "data files in specified folder.") parser.add_argument('-d', '--device', metavar='DEVICE', default='/dev/ttyXBEE', help='XBee serial device pseudofile') parser.add_argument('-b', '--baud', metavar='RATE', type=int, default=9600, help='Baud rate of XBee serial device.') parser.add_argument('folder', metavar='FOLDER', help='Folder for data files.') args = parser.parse_args(argv) ser = serial.Serial(args.device, args.baud) xbee = ZigBee(ser) if not os.path.exists(args.folder): os.makedirs(args.folder) # Continuously read and print packets while True: try: today = datetime.date.today() fname = '%4d-%02d-%02d.csv' % (today.year, today.month, today.day) response = xbee.wait_read_frame() source_addr_long = response['source_addr_long'].encode("hex") with open(os.path.join(args.folder, fname), 'a') as f: csvout = csv.writer(f) for sample in response['samples']: row = (time(), source_addr_long, tempAir(sample['adc-0']), tempWater(sample['adc-1'])) csvout.writerow(row) except KeyboardInterrupt: break ser.close()
def find_bots(): #The coordinator broadcasts a "Node Discover" AT command and records the addresses recieved, I suspect #Add coordinator first, then add on each bot as it responds. #robot id command global xbee ser = serial.Serial(DEVICE, 57600) xbee = ZigBee(ser) try: print("Searching for bots...") xbee.at( dest_addr_long = XBEE_ADDR_LONG, dest_addr = XBEE_ADDR_SHORT, command = 'ND' ) timeout = time.time() + 30 num_of_robots = 0 while timeout > time.time(): dict = xbee.wait_read_frame() if dict == None: break bot_array.append(parse_ND(dict)) print "Response: %r " % bot_array[num_of_robots] num_of_robots += 1 except KeyboardInterrupt, SerialException: sys.exit(0)
def main(): try: # Open serial port ser = serial.Serial('/dev/ttyUSB0', 9600) # Create XBee Series 2 object xbee = ZigBee(ser) DEST_ADDR_LONG = "\x00\x13\xA2\x00\x40\xE3\xCD\x1E" DEST_ADDR = "\xFF\xFE" # Send packet xbee.send('tx', dest_addr_long=DEST_ADDR_LONG, dest_addr=DEST_ADDR, data='WHOS A GOOD BOY') # Wait for response response = xbee.wait_read_frame() print response except KeyboardInterrupt: pass finally: ser.close()
def main(): serial_port = serial.Serial('/dev/ttyUSB0', 9600) xbee = ZigBee(serial_port) DEST_ADDR_LONG = "\x00\x13\xA2\x00\x40\xE3\xCD\x0F" DEST_ADDR = "\xFF\xFE" print "Attempting to receive..." while True: try: indata = xbee.wait_read_frame() rfdata = indata['rf_data'] print(addData(rfdata)) except KeyboardInterrupt: break serial_port.close()
def getRssi(): ser = serial.Serial(PORT, BAUD_RATE) xbee = ZigBee(ser,escaped=True) global sc global rss i=0 for data in routerdata: xbee.remote_at( #remote_at RSSI dest_addr_long=data[2], command="DB", frame_id="A") response=xbee.wait_read_frame() stat=response['status'] stat=ord(stat) if stat is 0: parDB = response['parameter'] parDB = ord(parDB) print data[0].upper(),"is alive. RSS is -",parDB,"dBm" data[3] = ","+data[0].upper()+","+str(ord(response['parameter'])) data[3] = data[3].upper() data[3] = re.sub('[^A-Zbcxy0-9\,]',"",data[3]) else: print "Can't connect to", data[0].upper() data[3] = ","+data[0].upper()+",," data[3] = re.sub('[^A-Zbcxy0-9\,]',"",data[3]) i=i+1 ser.close() return
def test_read_timeout(self): port = serial.Serial('/dev/ttyUSB0', 9600) xbee_device = ZigBee(port) self.settings.bind(xbee_device) self.assertRaises(ReadException, self.settings.read_all) xbee_device.halt() port.close()
def __init__(self, port, *args, **kwargs): self.port = port self.xb = ZigBee(self.port, callback=self.xbee_callback, error_callback=self.error_callback, escaped=False) super().__init__(*args, **kwargs) self.discover_nodes()
def linkxbee(q_down, q_up, e_pause, e_kill, config): """ собиралка телеметрии. получает пакет с xbee, тут же бросает в линию данные затем не спеша отрисовывает полученные данные """ # подсос значений из конфига baudrate = config.getint('Link', 'baudrate') port = config.getint('Link', 'port') # 2 стоп-бита стоит установить при наличии глюков с xbee на 115200 ser = serial.Serial(port, baudrate, stopbits=2) xbee = ZigBee(ser, escaped=True) device={"GND":'\x00\x13\xA2\x00\x40\x5D\xF9\xEA', "PNS":'\x00\x13\xA2\x00\x40\x5D\xF9\xE9'} xbee_response = None # пришедший с модема пакет msg_up = None # строка, которую надо запихнуть в пакет для отправки # ждем, пока нас снимут с паузы print "---- link ready" e_pause.wait() print "---- link run" while True: if e_kill.is_set(): print "=== Link. Kill signal received. Exiting" return # читаем из модема try: xbee_response = xbee.wait_read_frame() except: print "xbee not respond" # пихаем нагрузку из пришедшего пакета в очередь протокольного анализатора if (xbee_response != None) and (xbee_response['id'] == 'rx'): try: q_down.put_nowait(xbee_response['rf_data']) except Full: print "Input packet lost" # тут же берем из очереди сообщение для отправки try: msg_up = q_up.get_nowait() except Empty: pass if msg_up != None: # пихаем в модем xbee.send("tx", frame_id='\x00', dest_addr_long=device["PNS"], broadcast_radius = '\x01', dest_addr='\xFF\xFE', data=msg_up) msg_up = None
def __init__(self, ser, upload_queue, logging): # Create XBee library API object, which spawns a new thread logging.debug( 'XBee setup') self.zb = ZigBee(ser, callback=self.messageReceived) self.ser = ser self.queue = upload_queue self.logging = logging self.switchLongAddr = '12' self.switchShortAddr = '12'
def startCorrectZigbee(self, os_name=os.name): if not self.in_test_mode: if (os_name in self.communication_module): self.comm = self.communication_module[os_name]() self.serial = self.comm.setup() self.zigbee = ZigBee(self.serial) else: raise UnsupportedSystemError( "System {} not supported".format(os_name))
def __init__(self, serial_device, baud=9600, escaped=True): # Use escaped for XBees in API mode 2 self._ser = serial.Serial(serial_device, baud) self._xbee = ZigBee(self._ser, callback=self._handle_data, escaped=escaped) self._slave_nodes = {} # Slave nodes found using self.discover() self._message_queue = [] # Queued data messages incoming
def connect(self): """ Creates an Xbee instance """ try: self.log(logging.INFO, "Connecting to Xbee") self.xbee = ZigBee(self.serial, callback=self.process) except: return False return True
def __init__(self, serialPort = "/dev/ttyAMA0", baudRate = 9600): self.BPM = 0 self.temp = -100 self.motion = False self.pulseVoltage = 0 self.ser = serial.Serial(serialPort, baudRate) self.xbee = ZigBee(serial.Serial(serialPort, baudRate), escaped=False) self.bpmQueue = Queue.Queue() self.tempQueue = Queue.Queue() self.msgRxTime = 0
def wakeup(): ser = serial.Serial(PORT, BAUD_RATE) xbee = ZigBee(ser,escaped=True) xbee.send("tx",data="Wake up and get data\n",dest_addr_long=DEST_ADDR_LONG,dest_addr="\xff\xfe") resp = xbee.wait_read_frame() print "Wake up" ser.close() return
def __enter__(self): while True: try: self.ser = serial.Serial('/dev/ttyUSB0', 9600, timeout=1) break except serial.serialutil.SerialException: logging.error("could not establish serial connection") time.sleep(5) self.xbee = ZigBee(self.ser, callback=self.build_callback()) return self
def test(): #print "Output: %s value: %s" % (numOutput, value) ser = serial.Serial(PORT, BAUD_RATE) # ZB XBee here. If you have Series 1 XBee, try XBee(ser) instead xbee = ZigBee(ser) #MAC, number written on the back of the XBee module # CO1 = my coordinator # EP1 = my endpoint with 2 outputs. D12(UP) y D11(DOWN) device = { 'CO1': '\x00\x13\xA2\x00\x40\xA0\xD4\xA3', 'EP1': '\x00\x13\xa2\x00\x40\x99\x2e\x62' } #64 bit address xbee.remote_at(dest_addr_long = device['EP1'], command = 'P1', parameter = '\x05') sleep(1) xbee.remote_at(dest_addr_long = device['EP1'], command = 'P1', parameter = '\x04') sleep(1) xbee.remote_at(dest_addr_long = device['EP1'], command = 'P2', parameter = '\x05') sleep(1) xbee.remote_at(dest_addr_long = device['EP1'], command = 'P2', parameter = '\x04') sleep(1) ser.close()
def __init__(self, port): self.xb = ZigBee(port, callback=self.xbee_callback, escaped=True, start_callback=self.start_callback) try: self.xb.start() except Exception: # TODO: check the real exception threading throws up pass self.discover_nodes()
def test_readall(self): port = serial.Serial('/dev/ttyUSB0', 38400) xbee_device = ZigBee(port) self.settings.bind(xbee_device) read_settings = self.settings.read_all() #TODO: clearly we need to allow for other versions, etc. self.assertEqual(read_settings['Version'], '21A7 Coord(API)') #TODO: and this needs to be configurable self.assertEqual(read_settings['PAN ID'], '000000000BADFACE') xbee_device.halt() port.close()
def start(self): self.serial_device = serial.Serial(self.usb_device, BAUD_RATE) # async mode self.zigbee_coord = ZigBee(self.serial_device, callback=self._handle_frame) self.running = True self.logger.info("Coordinator started.") spawn(self._send_node_discover)
def main(): '''After parsing arguments , it instantiates an asynchronous dispatcher which creates a new thread for every packet that arrives. ''' # Argument parsing parser = ArgumentParser(description='Receives data from any number or XBee routers in API mode using Direct I/O and then uploads this information to Cosm.') parser.add_argument('--debug', help='prints everything that the coordinator receives', action='store_true', default=False) parser.add_argument('device_file', help='where the zigbee cordinator is connected', action='store') parser.add_argument('baud_rate', action='store', type=int) args = vars(parser.parse_args()) # Serial connection with the XBee try: ser = Serial(args['device_file'], args['baud_rate']) except SerialException as s: print 'Connection with the XBee could not be established... Exiting.' exit() print 'Listening on', args['device_file'], '...\n' # Asynchronous dispatcher dispatch = ZBDispatch(ser) dispatch.register( 'direct_io', direct_io_handler, lambda packet: packet['id']=='rx_io_data_long_addr', args['debug'] ) dispatch.register( 'io_data', xbee_arduino_handler, lambda packet: packet['id']=='rx', args['debug'] ) zb = ZigBee(ser, callback=dispatch.dispatch, escaped=True) # Main loop while True: try: sleep(.1) except KeyboardInterrupt as k: print '\nCTRL+C received. Exiting.' break # Close XBee connection zb.halt() ser.close()
class RemLight: def __init__(self, dev, dest_addr_long, dest_addr='\xFF\xFE'): self._serial = serial.Serial(dev, 9600) self._dest_addr_long = dest_addr_long self._dest_addr = dest_addr self._xbee = ZigBee(self._serial) def _sendByteArray(self, ba): data = '' for b in ba: data += chr(b) self._xbee.send('tx', data=data, dest_addr_long=self._dest_addr_long, dest_addr=self._dest_addr) def _constrain(self, color, max=100): if color < 0: color = 0 elif color > max: color = max return color def setColor(self, red, green, blue): cmd = [ CMD_SET_COLOR, self._constrain(red), self._constrain(green), self._constrain(blue) ] self._sendByteArray(cmd) def crossfade(self, colors): size = 0 data = [] for c in colors: data.append(self._constrain(c[0])) data.append(self._constrain(c[1])) data.append(self._constrain(c[2])) size += 3 cmd = [CMD_CROSSFADE] + data self._sendByteArray(cmd) def setCrossfadeWait(self, value): value = self._constrain(value, max=65535) cmd = [CMD_SET_CROSSFADE_WAIT, value / 255, value % 255] self._sendByteArray(cmd) def setCrossfadeHold(self, value): value = self._constrain(value, max=65535) cmd = [CMD_SET_CROSSFADE_HOLD, value / 255, value % 255] self._sendByteArray(cmd)
class RemLight: def __init__(self, dev, dest_addr_long, dest_addr='\xFF\xFE'): self._serial = serial.Serial(dev, 9600) self._dest_addr_long = dest_addr_long self._dest_addr = dest_addr self._xbee = ZigBee(self._serial) def _sendByteArray(self, ba): data = '' for b in ba: data += chr(b) self._xbee.send('tx', data=data, dest_addr_long=self._dest_addr_long, dest_addr=self._dest_addr) def _constrain(self, color, max=100): if color < 0: color = 0 elif color > max: color = max return color def setColor(self, red, green, blue): cmd = [CMD_SET_COLOR, self._constrain(red), self._constrain(green), self._constrain(blue)] self._sendByteArray(cmd) def crossfade(self, colors): size = 0 data = [] for c in colors: data.append(self._constrain(c[0])) data.append(self._constrain(c[1])) data.append(self._constrain(c[2])) size += 3 cmd = [CMD_CROSSFADE] + data self._sendByteArray(cmd) def setCrossfadeWait(self, value): value = self._constrain(value, max=65535) cmd = [CMD_SET_CROSSFADE_WAIT, value / 255, value % 255] self._sendByteArray(cmd) def setCrossfadeHold(self, value): value = self._constrain(value, max=65535) cmd = [CMD_SET_CROSSFADE_HOLD, value / 255, value % 255] self._sendByteArray(cmd)
def _init_xbee(self): ''' _init_xbee: None -> None This method should be called in run() of child process. ''' def receive_frame(api_frame): for monitor in self._monitors: addr = self.get_source_addr_long(api_frame) if addr == monitor.get_monitoring_address(): monitor.post_data_to_service(api_frame) self._ser = serial.Serial(self._port, self._baurate) self._xbee = ZigBee(self._ser, escaped=True, callback=receive_frame)
class ReceiverProcess(\ process.BaseProcess, xbeeparser.XBeeApiFrameBaseParser): ''' Base class of process to receive data from XBee ZB. There should be only one instance against one XBee coordinator. ''' def __init__(self, port='/dev/ttyAMA0', baurate=9600, log_level=logging.INFO): '''Initialize XBee instance with serial port and baurate. The baurate should be set to same value with XBee module. ''' self._logger = logging.getLogger(type(self).__name__) self._logger.setLevel(log_level) process.BaseProcess.__init__(self, log_level=log_level) xbeeparser.XBeeApiFrameBaseParser.__init__(self, log_level=log_level) self._port = port self._baurate = baurate def _init_xbee(self): ''' _init_xbee: None -> None This method should be called in run() of child process. ''' def receive_frame(api_frame): for monitor in self._monitors: addr = self.get_source_addr_long(api_frame) if addr == monitor.get_monitoring_address(): monitor.post_data_to_service(api_frame) self._ser = serial.Serial(self._port, self._baurate) self._xbee = ZigBee(self._ser, escaped=True, callback=receive_frame) def _terminate(self): ''' _terminate: None -> None Wait and join all thread and process. ''' # halt() must be called before closing the serial # port in order to ensure proper thread shutdown self._xbee.halt() self._ser.close() process.BaseProcess._terminate(self)
def exit_handler(): #This sends a stop command to all the robots on the field when #the program is ended. stop = BeeCommand() stop.command.direction = 0 stop.command.magnitude = 0 stop.command.turn = 0 stop.command.accel = 0 ser = serial.Serial(DEVICE, 57600) xbee = ZigBee(ser) xbee.tx( dest_addr_long=XBEE_ADDR_LONG, dest_addr=XBEE_ADDR_SHORT, data=prepare_move_cmd(stop.command), ) xbee.tx( dest_addr_long=XBEE_ADDR_LONG, dest_addr=XBEE_ADDR_SHORT, data=prepare_move_cmd(stop.command), ) xbee.tx( dest_addr_long=XBEE_ADDR_LONG, dest_addr=XBEE_ADDR_SHORT, data=prepare_move_cmd(stop.command), )
def listener(): global xbee ser = serial.Serial(DEVICE, 9600) xbee = ZigBee(ser, callback=print_data) rospy.init_node('cmd_vel_listener', anonymous=True) rospy.Subscriber("/cmd_vel", Twist, callback) rospy.spin() xbee.halt() ser.close()
def listener(): #initializes the subscriber that receives the movement commands global xbee ser = serial.Serial(DEVICE, 57600) xbee = ZigBee(ser) print "Coordinator ready to receive commands." #Every robot's Communicator publishes addresses and movement commands to this topic rospy.Subscriber("/cmd_hex", BeeCommand, callback) rospy.spin() xbee.halt() ser.close()
def __init__(self, arguments, usb_manager): """ Initialize the XBee configurator. """ if isinstance(arguments, Arguments): self._settings = arguments.get_settings("xbee_configurator") else: raise TypeError("'arguments' must be an instance of Arguments") self._usb_manager = usb_manager self._serial_connection = self._usb_manager.get_xbee_device() self._sensor = ZigBee(self._serial_connection) time.sleep(self._settings.get("startup_delay"))
def run(self): # types: (none) -> none # Connect to the local XBee self._logger.debug('Starting the XBee Network thread') serial_port = serial.Serial('/dev/ttyUSB0', 9600) xbee = ZigBee(serial_port, callback=self._xbee_event) # Loop until time to close while not self._kill_event.is_set(): self._kill_event.wait(XBEE_WAIT_INTERVAL) # Close the connection to the xbee xbee.halt() serial_port.close() self._logger.debug('XBee Network thread closing')
def __init__(self, serialPort, callback, fakeData=False): self.callback = callback self.fake = fakeData if self.fake: self.interval = 0.5 #Adjust theese numbers to change fake data generation self.speed = 20 self.height = 0 self.stopFlag = Event() fakeThread = Timer(self.stopFlag, self._fakeCallback, self.interval) fakeThread.start() else: self.port = serial.Serial(serialPort, BAUD_RATE) self.xbee = ZigBee(self.port, callback=self._recvCallback)
def main(): #move this to a setup() routine and call that here? ports = enum_ports() try: global serial_port serial_port = serial.Serial(ports[0], 9600) # above assumes that first port found will be the right one. print "Connected to serial port: ", ports[0] print "--------------------------------------------" except: print "Serial Exception raised. The following ports were found:" print ports sys.exit() """ try: #keeping this in case I have trouble with multiple usb connections serial_port = serial.Serial("/dev/ttyUSB0", 9600) except serial.SerialException: print "Serial Exception raised. Try another port." ports = enum_ports() sys.exit() """ global xbee xbee = ZigBee(serial_port, callback=receive_data) print "Enter control-c to bring back interpreter prompt (>>>) after message is displayed" print "Enter control-z to exit script (send to bg) and get back to terminal prompt ($)" print "(type fg at terminal prompt to resume execution)" print node_discovery() initiate_device_monitoring() initiate_msg_queue_monitoring()
def getLocation(): serial_port = serial.Serial( port='/dev/ttyUSB0', baudrate = 9600, parity=serial.PARITY_NONE, stopbits=serial.STOPBITS_ONE, bytesize=serial.EIGHTBITS, timeout=1) zb = ZigBee(serial_port) while 1: try: line = str(serial_port.readline().decode("utf-8")) line2=line.split("\n") line3=line.split(",") if(str(line3[0])=="$GPGGA"): msg = pynmea2.parse(line) lat=msg.latitude lon=msg.longitude #print(msg.latitude) #print(msg.longitude) return lat,lon except ValueError: print('catched')
def run(self): stop = False ser = serial.Serial(PORT, BAUD_RATE) xbee = ZigBee(ser) i = 0 count = 0 while(True): response = xbee.wait_read_frame() parsed = self.parse(response) if(self.parse(response) != None): if(len([x for x in parsed.fftMags if(x == 0)]) == len(parsed.fftMags)): count+= 1 print("TOTAL NONZEROS THUS FAR: " + str(count)) else: data_queue.append(parsed) ser.close
def port_initialize(device): # this one defines the port info of the coordinator try: #set up port info if device == 'mac': # select port name port = '/dev/tty.usbserial-DN018QQK' elif device == 'pi': port = '/dev/ttyS0' elif device == 'pi1': try: port = '/dev/ttyUSB0' except: port = '/dev/ttyUSB1' else: port = 'COM3' baud_rate = 19200 # baud_rate of USB/serial #connect serial port to zigbee module ser = serial.Serial(port, baud_rate) ser.reset_input_buffer() # clear port ser.reset_output_buffer() coor = ZigBee( ser, escaped=True ) #connect port with Xbee module, then we can control xbee by this interface return coor except Exception as err: method = 'error @initial_port module: port_initialize()' log_error(method, err)
def collect_from_zigbee(target, stream_id, device=DEFAULT_SERIAL_DEVICE, baud_rate=DEFAULT_BAUD_RATE): """Synchronously read from the serial port to target target can either be the URL of a couchdb server or a restkit resource instance. """ from xbee import ZigBee if not hasattr(target, "post"): target = Resource(target) serial_device = serial.Serial(device, baud_rate) headers = {"Content-Type": "application/json"} if stream_id is None: stream_prefix = "" else: stream_prefix = stream_id + "_" try: xbee = ZigBee(serial_device, escaped=True) # Continuously read and print packets while True: try: response = xbee.wait_read_frame() now = datetime.datetime.utcnow() timestamp = now.replace(microsecond=0).isoformat() + "Z" logging.debug(response) samples = response.get("samples", []) for sample in samples: for sensor_id, sensor_value in sample.iteritems(): target.post( headers=headers, payload=json.dumps( { # TODO: use a mapping mechanism instead of stream_id # prefix "datastream_id": stream_prefix + sensor_id, "value": sensor_value, "timestamp": timestamp, } ), ) except KeyboardInterrupt: break finally: serial_device.close()
def startCorrectZigbee( self, os_name=os.name ): if not self.in_test_mode: if ( os_name in self.communication_module ): self.comm = self.communication_module[os_name]() self.serial = self.comm.setup() self.zigbee = ZigBee( self.serial ) else: raise UnsupportedSystemError( "System {} not supported".format( os_name ) )
def __init__(self, port): self.xb = ZigBee(port,callback=self.xbee_callback,escaped=True,start_callback=self.start_callback) try: self.xb.start() except Exception: # TODO: check the real exception threading throws up pass self.discover_nodes()
class XbeeAPIWatcher(object): def __init__(self): self.FILE = open(settings.LOG_FILE_NAME, 'a') self.ser = None self.xbee = None self.last_message = None self.last_signal = None self._setup_serial() def _setup_serial(self): self.ser = serial.Serial(settings.SERIAL_PORT, 9600, timeout=0) self.xbee = ZigBee(self.ser, escaped=True) def _process_message(self, message): if message['id'] == 'rx': self.last_message = message logger.info(time.strftime('%Y-%m-%d %H:%M:%S')) # TODO: use a higher resolution timestamp self.xbee.send('at', command='DB') # wait for signal strength response elif message['id'] == 'at_response' and message['command'] == 'DB': logger.info('Signal Strength: -%ddBm' % ord(message['parameter'])) self.last_signal = ord(message['parameter']) data_string = '%s,%s,%s' % (time.strftime('%Y-%m-%d %H:%M:%S'), '-%d' % self.last_signal, self.last_message['rf_data'].strip('\r\n')) self.FILE.write('%s\r\n' % data_string) self.FILE.flush() try: ChickenAPI.add_data(data_string) except ConnectionError as e: logger.error(e) def start(self): while True: try: response = self.xbee.wait_read_frame() self._process_message(response) except KeyboardInterrupt: break def stop(self): self.xbee.halt() self.ser.close()
def main(): """ After parsing arguments (-h flag for help), it instantiates an asynchronous dispatcher which creates a new thread for every packet that arrives. """ # Argument parsing parser = ArgumentParser(description='Receives data from any number or XBee routers in API mode using Direct I/O and then uploads this information to Cosm.') parser.add_argument('--debug', help='prints everything that the coordinator receives', action='store_true', default=False) parser.add_argument('device_file', help='where the zigbee cordinator is connected', action='store') parser.add_argument('baud_rate', action='store', type=int) args = vars(parser.parse_args()) # Serial connection with the XBee try: ser = Serial(args['device_file'], args['baud_rate']) except SerialException as s: print s exit() print "Listening on", args['device_file'], "...\n" # Asynchronous dispatcher dispatch = ZBDispatch(ser) dispatch.register( "io_data", io_sample_handler, lambda packet: packet['id']=='rx_io_data_long_addr', args['debug'] ) zb = ZigBee(ser, callback=dispatch.dispatch) # Main loop while True: try: sleep(.1) except KeyboardInterrupt as k: print k break # Close XBee connection zb.halt() ser.close()
def __init__(self, ser=None, zigbee=None): self.zigbee = None if zigbee: self.zigbee = zigbee elif ser: self.zigbee = ZigBee(ser) self.handlers = [] self.names = set()
def __init__(self, ser=None, xbee=None, unhandled_callback=None): self.xbee = None if xbee: self.xbee = xbee elif ser: self.xbee = ZigBee(ser,escaped=True) self.unhandled = unhandled_callback self.handlers = [] self.names = set()
def PollDevice(serialId): logging.debug('Starting Process.') ser = serial.Serial("/dev/tty.{}".format(serialId), 9600) xbee = ZigBee(ser, escaped=True) sampleRate = 1 Alive = True while Alive: logging.debug('Getting data.') try: packet = xbee.wait_read_frame() logging.debug("Frame received") logging.debug(packet) SendToTeleceptor(packet) except Exception, e: logging.error('Error getting data') logging.error(e) Alive = False time.sleep(sampleRate)
def setup_xbee(self, serial_port, baud_rate): print "Setup XBee Device" try: ser = serial.Serial(serial_port, baud_rate) self.xbee = ZigBee(ser, escaped=True) except serial.serialutil.SerialException as e: print "Serial Error: ", e logging.warning("Serial error") logging.warning(str(e)) sys.exit(1)
def listener(): global xbee ser = serial.Serial(DEVICE, 9600) xbee = ZigBee(ser, callback=print_data) rospy.loginfo("xbee started") # in ROS, nodes are unique named. If two nodes with the same # node are launched, the previous one is kicked off. The # anonymous=True flag means that rospy will choose a unique # name for our 'talker' node so that multiple talkers can # run simultaenously. rospy.init_node('cmd_vel_listener', anonymous=True) rospy.Subscriber("/sociobots/cmd_vel", Twist, callback) # spin() simply keeps python from exiting until this node is stopped rospy.spin() xbee.halt() ser.close()
def listener(): global xbee ser = serial.Serial(DEVICE, 57600) xbee = ZigBee(ser) # in ROS, nodes are uniquely named. If two nodes with the same # node are launched, the previous one is kicked off. The # anonymous=True flag means that rospy will choose a unique # name for our 'talker' node so that multiple talkers can # run simultaenously. print "Ready to receive commands." rospy.init_node('cmd_vel_listener', anonymous=True) rospy.Subscriber("/cmd_hex", Command, callback) # spin() simply keeps python from exiting until this node is stopped rospy.spin() xbee.halt() ser.close()
class XBeeReader(SerialReader): def __init__(self, port, baud_rate, logger_name=__name__): SerialReader.__init__(self, port, baud_rate, logger_name=logger_name) self.xbee = ZigBee(self.ser) def _read_loop(self): while self.is_reading: frame = self.xbee.wait_read_frame() # Data packet - read in the data if frame['id'] == 'rx' or frame['id'] == 'rx_explicit': self.convert_to_json(frame['rf_data'])
class zbDataLogger: def __init__(self, port='/dev/ttyUSB0', baud=9600, escaped=True, appLog=None): self.appLog = appLog or logging.getLogger(__name__) self.port = port self.baud = baud self.escaped = escaped try: self.serial_port = serial.Serial(self.port, self.baud) self.xbee = ZigBee(self.serial_port, escaped=self.escaped) self.appLog.info("Successfully initialised ZigBee on " + self.port + " at " + str(self.baud) + " baud") except: self.appLog.error("Unable to initialise Zigbee on " + self.port + " at " + str(self.baud) + " baud") raise self.frame = "" self.msg = {} self.data = "" self.appHandlers = {} def getMsg(self): self.frame = self.xbee.wait_read_frame() # blocking self.rfdata = self.frame.get("rf_data") self.msg["source"] = "0x%0.16X" % struct.unpack(">Q",self.frame.get("source_addr_long")) # convert to friendly name if we have defined it if self.msg["source"] in friendly["xbees"]: self.msg["source"] = friendly["xbees"][self.msg["source"]] self.appLog.debug("Got message") self.msg["logtime"] = datetime.isoformat(datetime.now()) decodeHdr = struct.unpack("HHHH", self.rfdata[0:8]) self.msg["appID"]= "0x%0.4X" % decodeHdr[0] self.msg["msgType"] = "0x%0.4X" % decodeHdr[1] # convert to friendly names if we have defined them if self.msg["appID"] in friendly["appIDs"]: self.msg["appID"] = friendly["appIDs"][self.msg["appID"]] if self.msg["appID"] in friendly["msgTypes"]: if self.msg["msgType"] in friendly["msgTypes"][self.msg["appID"]]: self.msg["msgType"] = friendly["msgTypes"][self.msg["appID"]][self.msg["msgType"]] self.msg["reserved"] = decodeHdr[2] self.msg["length"] = decodeHdr[3] self.msg["data"] = self.rfdata[8:] if self.msg["length"] != len(self.msg["data"]): self.appLog.error("Incorrect data length in received packet. Rx: %s, Expected: %s" % (len(self.msg["data"]), self.msg["length"])) else: if self.msg["appID"] in self.appHandlers: self.appLog.debug("Handling application ID: %s" % self.msg["appID"]) return self.appHandlers[self.msg["appID"]].decode(self.msg) else: self.appLog.warn("No handler registered for appID %s, dropping message..." % self.msg["appID"]) return [] def register(self, appID, handler): self.appHandlers[appID] = handler self.appLog.info("Registered handler for appID: %s" % appID)
def node_discovery(): comPortList = getActiveComPort() if comPortList: comPort = comPortList[0].get('name') timeOut = int(comPortList[0].get('timeout')) baudRate = int(comPortList[0].get('baudrate')) count = 0 try: ser = serial.Serial(comPort, baudRate, timeout=timeOut) xbee = ZigBee(ser,escaped=True) node_list=[] xbee.at(command='ND') response = {'':''} while response <> {}: response = xbee.wait_read_frame() if response: print response node_list.append(response) else: text = "Xbee: Timeout during node discovery operation!" print "Spisak: ", node_list # return [] return node_list except serial.SerialException as ex: text = "Exception: " + ex.__str__() return text else: xbee.halt() ser.close()
def xbee_tp(xbeeRemAddr): """ XBee TP command implementation. Input: xbeeRemAddr. Ex: xbee_is('0013A200406B5174') """ comPortList = getActiveComPort() if comPortList: comPort = comPortList[0].get('name') timeOut = int(comPortList[0].get('timeout')) baudRate = int(comPortList[0].get('baudrate')) count = 0 try: ser = serial.Serial(comPort, baudRate, timeout=timeOut) xbee = ZigBee(ser,escaped=True) xbee.remote_at(dest_addr_long=xbeeRemAddr,command="TP",frame_id="C") response = xbee.wait_read_frame() return response except serial.SerialException as ex: text = "Exception is: " + ex.__str__() return 0 else: xbee.halt() ser.close()