Python xbee.ZigBee类代码示例

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

 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

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