Python ZigBee.wait_read_frame方法代码示例

# 需要导入模块: from xbee import ZigBee [as 别名]
# 或者: from xbee.ZigBee import wait_read_frame [as 别名]
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
        ser0 = serial.Serial('/dev/ttyUSB0', 9600)
        ser1 = serial.Serial('/dev/ttyUSB1', 9600)
        
        # Create XBee Series 1 object
        #xbee = XBee(ser)
	xbee = ZigBee(ser1, escaped=True)
        
        
        # Send AT packet
        xbee.send('at', frame_id='A', command='DH')
        
        # Wait for response
        response = xbee.wait_read_frame()
        print response
        
        # Send AT packet
        xbee.send('at', frame_id='B', command='DL')
        
        # Wait for response
        response = xbee.wait_read_frame()
        print response
        
        # Send AT packet
        xbee.send('at', frame_id='C', command='MY')
        
        # Wait for response
        response = xbee.wait_read_frame()
        print response
        
        # Send AT packet
        xbee.send('at', frame_id='D', command='CE')
        
        # Wait for response
        response = xbee.wait_read_frame()
        print response
    except KeyboardInterrupt:
        pass
    finally:
        ser0.close()
        ser1.close()

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

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

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

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

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

# 需要导入模块: from xbee import ZigBee [as 别名]
# 或者: from xbee.ZigBee import wait_read_frame [as 别名]
def main():
    args = setup_argparser()

    #setup serial port
    ser = serial.Serial(args.port, 9600)
    xbee = ZigBee(ser, escaped=True)

    exit_code = 0
    p = on if args.state == 1 else off

    if args.ack:
        #send command and request an acknowledge
        xbee.remote_at(dest_addr_long=to_hex(args.device), command=pin_to_command[args.gpio], parameter=p, frame_id=cmd_id)
        try:
            response = xbee.wait_read_frame()

            #sucessfully transmitted command
            if response['status'] == '\x00' and response['frame_id'] == cmd_id:
                print "command successfull"

            else:
                print "Command was not successful: ", status_help[response['status']]
                exit_code = ord(response['status'])

        except KeyboardInterrupt:
            print "cancel script"
    else:
        #send command without requesting ack
        xbee.remote_at(dest_addr_long=to_hex(args.device), command=pin_to_command[args.gpio], parameter=p)

    #clean up
    ser.close()
    exit(exit_code)

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

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

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

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

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

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

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

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