Python ZigBee.at方法代码示例

# 需要导入模块: from xbee import ZigBee [as 别名]
# 或者: from xbee.ZigBee import at [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 at [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 at [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 at [as 别名]
    def start(self):
        #------------------------------------------------------------------------------- 
        # Open serial port
        ser = serial.Serial('/dev/ttyAMA0', 9600)

        # Create API object
        xbee = ZigBee(ser,callback = self.print_data ,escaped=True)

        # Continuously read and print packets
        print "Starting"
        #print '\n *****************************'
        #print xbee.api_commands
        #print '\n *****************************'
        #print xbee.api_responses
        #print '\n *****************************'

        MY = self.HexToByte('0B41')
        ADR = self.HexToByte('0013A2004092D86A')

        once = 1
        while True:
            try: 
                
                #xbee.tx(dest_addr=pan,dest_addr_long=Destination, data='Hello World')
                #xbee.remote_at(dest_addr=MY,dest_addr_long=ADR, command='MY',parameter=None)
                #time.sleep(5) \x
                #xbee.send("remote_at",frame_id='A', command='MY')
                
                #
                #xbee.tx(dest_addr='\xbf\x0c',dest_addr_long='\x00\x13\xa2\x00\x40\x92\xd8\x6a', data='Hello World')
                    if once == 1:
                        print 'Discovering Nodes'
                        #xbee.at(frame_id='A', command='MY')
                        #xbee.at(frame_id='A', command='ID')
                        xbee.at(frame_id='D', command='ND')
                    
                    #xbee.remote_at(dest_addr='\xbf\x0c',command='IR',parameter='\xff')
                    #xbee.remote_at(dest_addr='\xbf\x0c',command='V+',parameter='\xff')
                    #xbee.remote_at(dest_addr='\xbf\x0c',command='MY',parameter=None)
                    
                        once = 0
                        time.sleep(5)
                        print 'Sending RAT'
                        #xbee.tx(dest_addr=MY2,dest_addr_long=ADR2, data='Hello World')
                        xbee.remote_at(dest_addr=MY,dest_addr_long=ADR,command='IS')
                        #time.sleep(1)
                        xbee.remote_at(dest_addr=MY,dest_addr_long=ADR,command='IR',parameter='\xFF')
                        #time.sleep(1)
                        xbee.remote_at(dest_addr=MY,dest_addr_long=ADR,command='IR',parameter='\x00')
                        print 'Done'
                    time.sleep(3)
            except KeyboardInterrupt:
                break

        xbee.halt()        
        ser.close()

# 需要导入模块: from xbee import ZigBee [as 别名]
# 或者: from xbee.ZigBee import at [as 别名]
once = 1
while True:
    try:

        # xbee.tx(dest_addr=pan,dest_addr_long=Destination, data='Hello World')
        # xbee.remote_at(dest_addr=MY,dest_addr_long=ADR, command='MY',parameter=None)
        # time.sleep(5) \x
        # xbee.send("remote_at",frame_id='A', command='MY')

        #
        # xbee.tx(dest_addr='\xbf\x0c',dest_addr_long='\x00\x13\xa2\x00\x40\x92\xd8\x6a', data='Hello World')
        if once == 1:
            print "Discovering Nodes"
            # xbee.at(frame_id='A', command='MY')
            # xbee.at(frame_id='A', command='ID')
            xbee.at(frame_id="D", command="ND")

            # xbee.remote_at(dest_addr='\xbf\x0c',command='IR',parameter='\xff')
            # xbee.remote_at(dest_addr='\xbf\x0c',command='V+',parameter='\xff')
            # xbee.remote_at(dest_addr='\xbf\x0c',command='MY',parameter=None)

            once = 0
            time.sleep(5)
            print "Sending RAT"
            # xbee.tx(dest_addr=MY2,dest_addr_long=ADR2, data='Hello World')
            xbee.remote_at(dest_addr=MY, dest_addr_long=ADR, command="IS")
            # time.sleep(1)
            xbee.remote_at(dest_addr=MY, dest_addr_long=ADR, command="IR", parameter="\xFF")
            # time.sleep(1)
            xbee.remote_at(dest_addr=MY, dest_addr_long=ADR, command="IR", parameter="\x00")
            print "Done"

# 需要导入模块: from xbee import ZigBee [as 别名]
# 或者: from xbee.ZigBee import at [as 别名]
xb.remote_at(command='D2', parameter=byte(0x02), dest_addr_long=dest)
wait()

xb.remote_at(command='D3', parameter=byte(0x02), dest_addr_long=dest)
wait()

# wiki says to enable digital input on the battery monitoring pin
xb.remote_at(command='P1', parameter=byte(0x03), dest_addr_long=dest)
wait()


# set up sleep

# set child timeout on local router (3*SP*SN)
xb.at(command='SP', parameter=short(0x03e8))
wait()
xb.at(command='SN', parameter=short(0x60))
wait()

# set power level (0 -8dBm,  1 -4 dBm, 2 -2 dBm, 3 -0 dBm, 4 +2 dBm)
xb.remote_at(command='PL', parameter=byte(0x04), dest_addr_long=dest)
wait()

# in units of 10ms
# range of 0x20 - 0xAF0
#xb.remote_at(command='SP', parameter=short(0x03e8), dest_addr_long=dest)
xb.remote_at(command='SP', parameter=short(0x03e8), dest_addr_long=dest)
#xb.remote_at(command='SP', parameter=b'\x07\xd0', dest_addr_long=dest)
wait()
# number of sleep periods (sleep = SP * SN)

# 需要导入模块: from xbee import ZigBee [as 别名]
# 或者: from xbee.ZigBee import at [as 别名]
short_int = eval(config.get('node','short_addr'))
short_daddr = pack(">H", short_int)
long_daddr = pack('>Q',eval(config.get('node','long_addr'))) # set 64-bit address here

print "parsed short_daddr=%s\n" % repr(short_daddr)
print "parsed long_daddr=%s\n" % repr(long_daddr)


ser = serial.Serial(config.get('modem', 'port'), 57600)
xb = ZigBee(ser,callback=cb,escaped=True,start_callback=scb)
xb.start()



print xb.at(command='ND')

if 0:
    while True:
        print "one"
        for x in range(0xFF):
            data = pack('BBBB', 0, x,x,x)
            xb.tx( dest_addr = short_daddr , dest_addr_long = long_daddr, data = data )
            time.sleep(0.1)

if 0:
    print "foo"
    data = pack('BBBB', 0, 0xff,0xff,0xff)
    xb.tx( dest_addr = short_daddr, dest_addr_long = long_daddr, data = data )

# 需要导入模块: from xbee import ZigBee [as 别名]
# 或者: from xbee.ZigBee import at [as 别名]
import glob
import signal
import serial
from xbee import ZigBee


def signal_shutdown(signum, frame):
    xbee.halt()
    ser.close()

# Halt XBee and closer serial upon SIGINT (Ctrl-C)
signal.signal(signal.SIGINT, signal_shutdown)

SERIALPORT = glob.glob('/dev/tty.usbserial*')[0]
ser = serial.Serial(SERIALPORT, 9600)
xbee = ZigBee(ser)

# Set `Node Discovery Timeout` to X * 100ms
xbee.send('at', frame='A', command='NT', parameter='\xFF')
xbee.at(command='ND')

while True:
    response = xbee.wait_read_frame()
    if ('command' in response) and (response['command'] == 'ND'):
        print response
        print response['parameter']['node_identifier']
        break


signal_shutdown(0, None)

# 需要导入模块: from xbee import ZigBee [as 别名]
# 或者: from xbee.ZigBee import at [as 别名]
#! /usr/bin/python

# Import and init an XBee device
from model import *
from xbee import ZigBee



if __name__ == '__main__':
    srlc = serial.Serial('COM7', 9600)
    xbc = ZigBee(srlc)
    # srle = serial.Serial('COM5', 9600)
    # xbe = XBee(srle)
    a = b'ND'
    xbc.at(command=bytes('ND', encoding='utf-8'))

    resc1 = xbc.wait_read_frame()
    print(resc1)
    resc2 = xbc.wait_read_frame()
    print(resc2)
    xbc.remote_at(
        dest_addr=b'\x56\x78',
        command=b'D2',
        parameter=b'\x04')

    xbc.remote_at(
        dest_addr=b'\x56\x78',
        command=b'WR')

    # Use an XBee 802.15.4 device
    # To use with an XBee ZigBee device, replace with:

# 需要导入模块: from xbee import ZigBee [as 别名]
# 或者: from xbee.ZigBee import at [as 别名]
import serial.tools.list_ports


#PORT = '/dev/ttyUSB0'
BAUD_RATE = 9600

ports = list(serial.tools.list_ports.comports())
for p in ports:
    # The SparkFun XBee Explorer USB board uses an FTDI chip as USB interface
    if "FTDIBUS" in p[2]:
        print "Found possible XBee on " + p[0]
        if not portfound:
            portfound = True
            portname = p[0]
            print "Using " + p[0] + " as XBee COM port."
        else:
            print "Ignoring this port, using the first one that was found."
 
if portfound:
    ser = serial.Serial(portname, 9600)
else:
    sys.exit("No serial port seems to have an XBee connected.")

ser = serial.Serial(PORT, BAUD_RATE)
xbee = ZigBee(ser=ser, escaped=True)



xbee.at(command="AT")

print xbee.wait_read_frame()

# 需要导入模块: from xbee import ZigBee [as 别名]
# 或者: from xbee.ZigBee import at [as 别名]
			accesslock.release()
			print "device added to list...."
			print DeviceList
	elif data['id']=="rx":
		rx_data = data['rf_data']
		NetworkInfo[data['source_addr_long']].insert(2,rx_data)
		print NetworkInfo[data['source_addr_long']][0] + " sent to co-ordinator: " + NetworkInfo[data['source_addr_long']][2]
	elif DEBUG:
		print data
	return 0

zb = ZigBee(ser,callback=msg_pack)

#---Zigbee Node ping----------
print "Acquiring Node addresses..."
zb.at(command="ND")

def plotwaypoints():
	writehtml = open('plot_waypoints_gmaps.html','w')
	node_num = 0
	for key in NetworkInfo.keys():
		plot_data = NetworkInfo[key][2].split(",")
		nodes.append([NetworkInfo[key][0],plot_data[0],plot_data[1],node_num])
		node_num+=1
	print str(nodes)
	message = """
<!DOCTYPE html>
	<html> 
	<head> 
		<meta http-equiv="content-type" content="text/html; charset=UTF-8" /> 
  		<title>Google Maps Multiple Markers</title> 

# 需要导入模块: from xbee import ZigBee [as 别名]
# 或者: from xbee.ZigBee import at [as 别名]
        current_file.write(current_data)
        current_file.write('\n')
        current_file.close()
    reads = reads+1
    print ("Recieved data: {0}".format(reads))

#-----Scheduler----------
SchedDataCollect = Scheduler()
#------------------------

if __name__ == '__main__':
    # Code to be executed when the script is called directly
    while packets.qsize() > 0:
        newPacket = packets.get_nowait()
    # Send ND command - responses will create a list of addresses
    xbee.at(command=b'ND')

    numReaders = int(raw_input("How many readers?"))
    while len(XBeeID) != numReaders:
        try:
            if packets.qsize() > 0:
                newPacket = packets.get_nowait()
                handlePacket(newPacket)
        except KeyboardInterrupt:
            break
    
    # Ask for specific file names for each XBee ID:
    for x in range(0,len(XBeeID)):
        XBeeFilenames.append(raw_input("Identifier {0} filename:".format(XBeeID[x])))
        # Change save_file to the file destination for your server
        save_file = '/media/usbhdd/'

# 需要导入模块: from xbee import ZigBee [as 别名]
# 或者: from xbee.ZigBee import at [as 别名]
class XBeeInterface(object):
    """
    Interfaces between an XBee connected through a serial port and messages
    passed through stdin/stdout. Uses a simple JSON protocol to encode message
    parameters.
    """
    def __init__(self, port, baud, escaped):

        self.serial_port = Serial(port, baud)
        self.xbee = ZigBee(self.serial_port, escaped=escaped)

        # Reopen stdin/stdout in line-buffered mode
        self.stdin = os.fdopen(sys.stdin.fileno(), 'r', 1)
        self.stdout = os.fdopen(sys.stdout.fileno(), 'w', 1)

        # Associate each file descriptor with handler methods
        self.handlers = {
            self.serial_port.fileno(): (self.read_frame, self.on_frame),
            self.stdin.fileno(): (self.read_message, self.on_message)
        }

        # Turn on non-blocking IO
        for fd in self.handlers.keys():
            fcntl.fcntl(fd, fcntl.F_SETFL, os.O_NONBLOCK)

    def run(self):
        # Send an AT command to trigger a response from the module
        self.xbee.at(command='NI')
        response = self.xbee.wait_read_frame()
        log.info('Network identifier is "%s"', response['parameter'])

        while True:
            # do non-blocking reading from stdin and serial port
            r, w, x = select.select(self.handlers.keys(), [], [])

            for fd in r:
                read_handler, data_handler = self.handlers[fd]
                data = read_handler()

                # read handlers return None if message is gimped
                if data is not None:
                    data_handler(data)


    def read_frame(self):
        """ Read an entire frame from the serial connection and return it """
        try:
            return self.xbee.wait_read_frame()
        except ValueError as e:
            log.warning('error in packet data: %s', e)
            return None
        except SerialException as e:
            log.error('error reading serial frame: %s', e)
            raise IOError("Error reading from serial port")

    def read_message(self):
        """ Read a line from stdin and parse it as JSON """
        try:
            line = self.stdin.readline()
            return json.loads(line)
        except ValueError as e:
            log.error('error decoding message: %s', e)
            return None

    def json_message(self, data):
        """ Write a JSON string to stdout, using latin1 encoding to keep binary
        data intact """
        json_str = json.dumps(data, encoding='latin1')
        self.stdout.write(json_str + '\n')

    def on_message(self, message):
        log.info('Message received from stdin: %s', message)

        try:
            # delegate to another method specified by action
            action = '_'.join(('do', message['action']))
            if not hasattr(self, action):
                return log.error('Unknown action "%s"', message['action'])
            getattr(self, action)(message)
        except KeyError as e:
            return log.error('Message is missing "%s"', e.message)


    def do_send(self, message):
        """ Sends a transmit request to the module """
        # encode as latin1 to get back byte string
        address, data, frame_id = (
                message['address'].encode('latin1'),
                message['data'].encode('latin1'), 
                message.get('frame_id', u'\x01').encode('latin1'))

        try:
            self.xbee.tx(data=data, frame_id=frame_id,
                    dest_addr_long=address, dest_addr='\xFF\xFE')
        except Exception as e:
            return log.error('Failed to send transmit request: %s', e)


    def do_discover(self, message):
        frame_id = message.get('frame_id', u'\x01').encode('latin1')
#.........这里部分代码省略.........

# 需要导入模块: from xbee import ZigBee [as 别名]
# 或者: from xbee.ZigBee import at [as 别名]
#set serial communication with xbee
ser = serial.Serial('/dev/cu.usbserial-AD025EOA', 9600)

#python xbee api doesn't implmenet timeout on read
#to work around this, set signal alarm to trigger timout

#set signal for timeout
signal.signal(signal.SIGALRM, exceptionHandler)

#create instance of zigbee
xbee = ZigBee(ser)

hb = 0x00
lb = 0x00

xbee.at(command='ID')
ret = xbee.wait_read_frame()
print "Current ID"
print ret
exit()
fd = open("scanlog.txt", "w+")

while 1:
    if hb > 0xFF:
        break
    rb = lb << 8 | hb
    fd.write("[*] pan id 0x%02x%02x\n" % (hb,lb))
    try:    
        #change pan id and query id command with argument 
        arg = struct.pack('h', rb)
        xbee.at(command='ID', parameter=arg)

# 需要导入模块: from xbee import ZigBee [as 别名]
# 或者: from xbee.ZigBee import at [as 别名]
class handler(object):
    port = None
    nodes_by_identifier = {}
    nodes_by_shortaddr = {}
    xb = None

    def xbee_callback(self, x):
        print "DEBUG: x=%s" % repr(x)
        
        node_discovery_info = None
        
        if (    x['id'] == 'at_response'
            and x['command'] == 'ND'):
            # Node discovery response
            node_discovery_info = x['parameter']

        if (x['id'] == 'node_id_indicator'):
            node_discovery_info = x
            node_discovery_info['node_identifier'] = x['node_id']

        if (    node_discovery_info
            and node_discovery_info.has_key('node_identifier')
            and node_discovery_info.has_key('source_addr')
            and node_discovery_info.has_key('source_addr_long')):
            # Node discovery packet
            node = XbeeNode(self.xb, short_addr=node_discovery_info['source_addr'], long_addr=node_discovery_info['source_addr_long'], node_identifier=node_discovery_info['node_identifier'])
            self.nodes_by_identifier[node.node_identifier] = node
            sa_hex = binascii.hexlify(node.short_addr)
            self.nodes_by_shortaddr[sa_hex] = node
            print "New node %s at 0x%s" % (node.node_identifier, sa_hex)

    def start_callback(self, x):
        print "DEBUG: start_callback, x=%s" % repr(x)
        pass

    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 discover_nodes(self):
        self.xb.at(command='ND')

    def ping_nodes(self):
        """Ping each known node to make sure it's still alive, if not remove from node list (or maybe just mark dead somehow)"""
        pass        

    def tx_all(self, *args):
        for nodeid in self.nodes_by_identifier.keys():
            print "Sending to %s" % nodeid
            self.nodes_by_identifier[nodeid].tx(*args)
        print "All sent"

    def tx_string_all(self, *args):
        for nodeid in self.nodes_by_identifier.keys():
            print "Sending to %s" % nodeid
            self.nodes_by_identifier[nodeid].tx_string(*args)
        print "All sent"