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 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 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 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 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 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()
def find_bots():
global xbee
ser = serial.Serial(DEVICE, 57600)
xbee = ZigBee(ser)
try:
print("Searching for bots. This may take a moment.")
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():
dictl = xbee.wait_read_frame()
if dictl == None:
break
bot_array.append(parse_ND(dictl))
num_of_robots += 1
except KeyboardInterrupt:
sys.exit(0)
class SensorNetwork:
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 discover(self, timeout=0):
"""Initiate a node discovery.
Args:
timeout (int): Seconds before function returns.
"""
logger.debug('Starting node discovery...')
self._xbee.at(command='ND')
if timeout > 0:
time.sleep(timeout)
def get_node_ids(self):
"""Get IDs of all slave nodes.
Returns:
list of addr: List of slave node IDs.
"""
return self._slave_nodes.keys()
def get_nodes(self):
"""Get all slave nodes.
Returns:
list of Node: List of slave nodes.
"""
return self._slave_nodes.values()
def get_node_by_id(self, id):
"""Get a node by it's ID.
Args:
id: Node ID.
Returns:
Node: Node represented by ID.
"""
return self._slave_nodes.get(id)
def node_exists(self, id):
"""Test if a node exists in the slave nodes.
Args:
id: Node ID.
Returns:
bool: True if node ID exists in slave nodes, else False.
"""
return id in self._slave_nodes
def _handle_data(self, data):
"""Internal function to handle data responses from XBee API."""
if 'rf_data' in data.keys():
if data['rf_data'][0] == Packet.IO_RESPONSE.value:
self._message_queue.append(data)
logger.debug('Received IO_RESPONSE, added to queue.')
elif data['rf_data'][0] == Packet.INFO_RESPONSE.value:
self._message_queue.append(data)
logger.debug('Received INFO_RESPONSE, added to queue.')
elif data['rf_data'][0] == Packet.DATA_RESPONSE.value:
self._message_queue.append(data)
logger.debug('Received DATA_RESPONSE, added to queue.')
elif data['rf_data'][0] == Packet.CTRL_ACK.value:
self._message_queue.append(data)
logger.debug('Received ACK, added to queue.')
elif data['rf_data'][0] == Packet.CTRL_NACK.value:
self._message_queue.append(data)
logger.debug('Received NACK, added to queue.')
else:
print('Unknown data: {}'.format(data['rf_data']))
elif 'id' in data.keys() and data[
'id'] == 'tx_status': # Every transmission returns a tx_status packet
if data['deliver_status'] != b'\x00':
logger.error('Transmission was not delivered!')
logger.error(data)
elif 'command' in data.keys():
command = data['command'].decode('utf-8')
if command == 'ND': # XBee node discovery AT command
params = data['parameter']
node = Node(params['source_addr_long'],
params['node_identifier'])
logging.debug("Found node at {}".format(node.addr))
self._slave_nodes[node.addr] = node
else:
logger.error('Unsupported command: {}'.format(command))
else:
logger.error('Received unknown packet:')
logger.error(data)
def stop(self):
"""Stop radio listener & handler."""
logger.info('Stopping...')
self._xbee.halt()
self._ser.close()
def _wait_for_response(self,
node,
type_,
fail_type,
following=None,
count=None,
timeout=None):
"""Internal function to wait until data arrives meeting specific constraints.
Args:
node (Node): Node to wait for data from (using long_addr).
type_ (Packet): Packet type required
fail_type (Packet): Packet type transimitted before wait called.
following (bytes): Byte sequence required following type_ byte.
count (int): Total number of bytes in packet required (including type byte).
Returns:
bytes: Data bytes after type byte.
"""
if timeout is None:
timeout = 0
timer = time.time() + timeout
while True:
for msg in self._message_queue:
if 'source_addr_long' in msg.keys(
) and msg['source_addr_long'] == node.long_addr:
# Message is from target node
if len(msg['rf_data']
) > 0 and msg['rf_data'][0] == type_.value:
if following is None and count is None:
self._message_queue.remove(msg)
return msg['rf_data'][1:]
# Just following
elif count is None and len(
msg['rf_data']) > len(following) and msg[
'rf_data'][1:len(following) +
1] == following:
self._message_queue.remove(msg)
return msg['rf_data'][1:]
# Just count
elif following is None and len(
msg['rf_data']) == count:
self._message_queue.remove(msg)
return msg['rf_data'][1:]
# Following AND count
elif len(msg['rf_data']) == count and len(
msg['rf_data']) > 1 + len(following) and msg[
'rf_data'][1:len(following) +
1] == following:
self._message_queue.remove(msg)
return msg['rf_data'][1:]
# Check for NACK of same type
if len(msg['rf_data']) == 2 and msg['rf_data'][
0] == Packet.CTRL_NACK.value and msg['rf_data'][
1] == fail_type.value:
self._message_queue.remove(msg)
raise ProtocolError(
"Node returned NACK, did you ask for something which doesn't exist?"
)
if timeout > 0 and time.time() > timer:
raise ProtocolError('Did not recieve any data from node.')
def get_node_io(self, node, timeout=None):
"""Get IO presented by node.
Args:
node (Node): Node to inspect.
Returns:
dict of Packet to int: Packet IO type mapped to quantity.
"""
if type(node) != Node: # Check node is a Node
raise TypeError('Invalid node.')
self._xbee.tx(dest_addr_long=node.long_addr,
data=bytes([Packet.IO_REQUEST.value]))
logger.info('Waiting for IO_RESPONSE')
out = {}
# Loop over each byte as each represents a device
for b in self._wait_for_response(node,
Packet.IO_RESPONSE,
Packet.IO_REQUEST,
timeout=timeout):
out[Node.Payload(
b >> 4)] = (b & 15) + 1 # +1 to 1-index number of devices
return out
def get_payload_info(self, node, payload, index=0, timeout=None):
"""Get information about payload presented by node.
Args:
node (Node): Node to inspect.
payload (Node.Payload): Payload type to inspect.
index (int): Address of payload if node presents multiple.
Returns:
bytes: Raw bytes sent from node upon querying for information about payload
"""
if type(node) != Node: # Check node is a valid Node
raise TypeError('Invalid node.')
if type(payload
) != Node.Payload: # Check payload is a valid Node.Payload
raise TypeError('Invalid IO payload.')
if type(index) != int:
raise TypeError('Invalid index.')
if index < 0 or index > 15:
raise ValueError('Index out of bounds (0-15).')
self._xbee.tx(dest_addr_long=node.long_addr,
data=bytes([
Packet.INFO_REQUEST.value,
(payload.value << 4) + index
]))
logger.info('Waiting for INFO_RESPONSE')
data = self._wait_for_response(node,
Packet.INFO_RESPONSE,
Packet.INFO_REQUEST,
following=bytes([
(payload.value << 4) + index
]),
timeout=timeout)
return data[1:]
def get_data(self, node, payload, index=0, timeout=None):
"""Get data from node supporting data sourcing.
Args:
node (Node): Node to retrieve data from.
payload (Node.Payload): Payload type to retrieve data for.
index (int): Address of payload if node presents multiple.
Returns:
bytes or int or list of bool:
If requesting an analog value, returns int of value.
If requesting a digital output, returns list of bool containing 8 values.
Otherwise, bytes of raw data.
"""
if type(node) != Node: # Check node is a valid Node
raise TypeError('Invalid node.')
if type(payload
) != Node.Payload: # Check payload is a valid Node.Payload
raise TypeError('Invalid IO payload.')
if type(index) != int:
raise TypeError('Invalid index.')
if payload in (Node.Payload.DIGITAL_INPUT, Node.Payload.BYTE_INPUT):
raise ValueError('Cannot get data out of a sink node.')
if index < 0 or index > 15:
raise ValueError('Index out of bounds (0-15).')
self._xbee.tx(dest_addr_long=node.long_addr,
data=bytes([
Packet.DATA_REQUEST.value,
(payload.value << 4) + index
]))
logger.info('Waiting for DATA_RESPONSE')
if payload == Node.Payload.DIGITAL_OUTPUT: # Return tuple of True/False values representing data
data = self._wait_for_response(node,
Packet.DATA_RESPONSE,
Packet.DATA_REQUEST,
following=bytes([
(payload.value << 4) + index
]),
count=3,
timeout=timeout)[1:]
return [(int(data[0]) & 1 << i) >> i == 1
for i in reversed(range(0, 8))]
elif payload == Node.Payload.INT_1B_OUTPUT: # Return number represented by byte data
data = self._wait_for_response(node,
Packet.DATA_RESPONSE,
Packet.DATA_REQUEST,
following=bytes([
(payload.value << 4) + index
]),
count=3,
timeout=timeout)[1:]
return int(data[0])
elif payload == Node.Payload.INT_2B_OUTPUT: # Return number represented by byte data
data = self._wait_for_response(node,
Packet.DATA_RESPONSE,
Packet.DATA_REQUEST,
following=bytes([
(payload.value << 4) + index
]),
count=4,
timeout=timeout)[1:]
return int((data[0] << 8) + data[1])
elif payload == Node.Payload.BYTE_OUTPUT: # Return raw bytes
return self._wait_for_response(node,
Packet.DATA_RESPONSE,
Packet.DATA_REQUEST,
following=bytes([
(payload.value << 4) + index
]),
timeout=timeout)[1:]
def send_data(self, node, payload, data, index=0, timeout=None):
"""Send data to a node supporting data sinking.
Args:
node (Node): Node to send data to.
payload (Node.Payload): Payload type of data to send.
data: Data to be sent to device, type dependant on payload.
index (int): Address of payload on node if multiple available.
"""
if type(node) != Node: # Check node is a valid Node
raise TypeError('Invalid node.')
if type(payload
) != Node.Payload: # Check payload is a valid Node.Payload
raise TypeError('Invalid IO payload.')
if type(index) != int:
raise TypeError('Invalid index.')
if payload not in (Node.Payload.DIGITAL_INPUT, Node.Payload.BYTE_INPUT,
Node.Payload.INT_1B_INPUT,
Node.Payload.INT_2B_INPUT):
raise ValueError('Cannot send data to a source node.')
if index < 0 or index > 15:
raise ValueError('Index out of bounds (0-15).')
if payload == Node.Payload.BYTE_INPUT:
self._xbee.tx(
dest_addr_long=node.long_addr,
data=bytes(
[Packet.SET_REQUEST.value,
(payload.value << 4) + index]) + data)
elif payload == Node.Payload.INT_1B_INPUT:
if type(data) != int:
raise TypeError('Invalid data type for INT_1B_Input.')
if data < 0 or data > 255:
raise ValueError('Data out of bounds (0-255).')
self._xbee.tx(dest_addr_long=node.long_addr,
data=bytes([
Packet.SET_REQUEST.value,
(payload.value << 4) + index, data
]))
elif payload == Node.Payload.INT_2B_INPUT:
if type(data) != int:
raise TypeError('Invalid data type for INT_2B_Input.')
if data < 0 or data > 65535:
raise ValueError('Data out of bounds (0-65535).')
self._xbee.tx(dest_addr_long=node.long_addr,
data=bytes([
Packet.SET_REQUEST.value,
(payload.value << 4) + index, data >> 8,
data & 255
]))
elif payload == Node.Payload.DIGITAL_INPUT:
if type(data) not in (list, tuple) or len(data) != 8:
raise ValueError(
"Data is not in correct format for specified payload type."
)
out = 0
for i in reversed(range(0, 8)):
if type(data[i]) != bool:
raise ValueError(
"Data is not in correct format for specified payload type."
)
if data[i] == True:
out += 1 << i
print(out)
self._xbee.tx(dest_addr_long=node.long_addr,
data=bytes([
Packet.SET_REQUEST.value,
(payload.value << 4) + index, out
]))
logger.info('Waiting for ACK after having sent data')
self._wait_for_response(node,
Packet.CTRL_ACK,
Packet.SET_REQUEST,
following=bytes([Packet.SET_REQUEST.value]),
timeout=timeout)
@staticmethod
def convert_payload(payload, data):
if payload == Node.Payload.BYTE_INPUT:
return bytes([data])
class ZigbeeSerial:
def __init__(self,
rx_queue: Queue,
tx_queue: Queue,
port='/dev/ttyS0',
baudrate=9600):
self.ser = serial.Serial(port=port, baudrate=baudrate)
# And begin listening for packets
self.xbee = ZigBee(self.ser,
escaped=True,
callback=self.zigbee_callback)
# Store the reference to the queues
self.rx_queue = rx_queue
self.tx_queue = tx_queue
# After the serial port has been opened then configure the ZigBee module
self.set_api_mode()
self.set_as_coordinator()
def __del__(self):
print("Closing serial")
if hasattr(self, 'ser'):
self.ser.close()
def set_api_mode(self):
"""
Set the attached zigbee module to API mode so that it will work with the ZigBee module
"""
# Enter AT command mode
print("+++")
self.ser.write(b"+++")
# self.print_serial(3)
# Reset the module
print("Reset Module")
self.ser.write(b"ATRE\r\n")
# self.print_serial(3)
# Set the module into API mode with escaping
print("Set API mode to 2")
self.ser.write(b"ATAP 2\r\n")
# self.print_serial(3)
# Write the settings to the module
print("Write settings")
self.ser.write(b"ATWR\r\n")
# self.print_serial(3)
print("Drop out of command mode")
self.ser.write(b"ATCN\r\n")
# self.print_serial(3)
def set_as_coordinator(self):
"""
Since this code is to be run on the base station only we can assume that
this zigbee module will be the coordinator and we can set it as such
"""
# Set the module network ID
print("Setting network ID")
self.xbee.at(command=b'ID', parameter=b'\xbe\xef')
# print(self.xbee.wait_read_frame())
print("Network ID set to")
self.xbee.at(command=b'ID')
# print(self.xbee.wait_read_frame())
# Set this module as the Non-Routing Coordinator
print("Setting module type")
self.xbee.at(command=b'CE', parameter=b'3')
# print(self.xbee.wait_read_frame())
print("Module set as ")
self.xbee.at(command=b'CE')
# print(self.xbee.wait_read_frame())
def zigbee_callback(self, data):
"""
We will need two things from the data every time. First is the long address and the second is the rf_data.
Anything that was received over the serial connection will be slightly parsed and then sent to the queue.
"""
print('zigbee_callback')
# The data will only contain source_addr_long when it comes from an external zigbee, and not a setup command.
if 'source_addr_long' in data:
# Decode the source address
source_address = binascii.hexlify(
data['source_addr_long']).decode()
print(source_address)
# Take the received rf data, decode it as UTF-8, remove the \n from the end of the string and split on tabs.
print(data['rf_data'])
print(data['rf_data'].decode())
parsed_data = data['rf_data'].decode()[:-1].split("\t")
print(parsed_data)
self.rx_queue.put({
'address': source_address,
'data': parsed_data,
})
else:
# If this is a setup command then just print the data.
print(data)
def send_packet(self, address, body):
self.xbee.send('tx',
dest_addr_long=bytearray.fromhex(address),
data=body.encode('UTF-8'))
#! /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:
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')
self.xbee.at(command='ND', frame_id=frame_id)
def on_frame(self, frame):
log.debug('Frame received from device: %s', frame)
try:
event = '_'.join(('on_frame', frame['id']))
getattr(self, event)(frame)
except (AttributeError, KeyError):
log.warning('unhandled frame: %s', frame)
def on_frame_rx(self, frame):
log.info('Received message from %s/%s', hexify(frame['source_addr_long']),
hexify(frame['source_addr']))
self.json_message(frame)
def on_frame_tx_status(self, frame):
log.info('Transmit status for frame %s: %s', frame['frame_id'],
'success' if frame['deliver_status'] == '\x00' else 'failure')
self.json_message(frame)
def on_frame_at_response(self, frame):
log.info('AT response for frame %s: "%s"',
frame['frame_id'], frame['parameter'])
self.json_message(frame)
from serial import Serial
from xbee import ZigBee
if __name__ == "__main__":
port = Serial("COM5", 9600, timeout=3)
print("Port set up")
my_device = ZigBee(port)
print("Device created")
while True:
print("In loop")
dat = my_device.wait_read_frame()
dat = my_device.at(command=b'DB')
print("After wait")
print(dat)
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>
class XBeeSerial:
def __init__(self, port='/dev/ttyS0', baudrate=9600):
self.ser = serial.Serial(port=port, baudrate=baudrate)
self.xbee = ZigBee(self.ser, escaped=True)
self.set_api_mode()
self.set_as_coordinator()
def __del__(self):
print("Closing serial")
if hasattr(self, 'ser'):
self.ser.close()
def set_api_mode(self):
# Enter AT command mode
self.ser.write(b"+++")
self.print_serial(3)
# Reset the module
print("Reset Module")
self.ser.write(b"ATRE\r\n")
self.print_serial(3)
# Set the module into API mode with escaping
print("Set API mode to 2")
self.ser.write(b"ATAP 2\r\n")
self.print_serial(3)
# Write the settings to the module
print("Write settings")
self.ser.write(b"ATWR\r\n")
self.print_serial(3)
print("Drop out of command mode")
self.ser.write(b"ATCN\r\n")
self.print_serial(3)
def set_as_coordinator(self):
# Set the module network ID
print("Setting network ID")
self.xbee.at(command=b'ID', parameter=b'\xbe\xef')
print(self.xbee.wait_read_frame())
print("Network ID set to")
self.xbee.at(command=b'ID')
print(self.xbee.wait_read_frame())
# Set this module as the Non-Routing Coordinator
print("Setting module type")
self.xbee.at(command=b'CE', parameter=b'3')
print(self.xbee.wait_read_frame())
print("Module set as ")
self.xbee.at(command=b'CE')
print(self.xbee.wait_read_frame())
def print_serial(self, bytes):
self.ser.flush()
time.sleep(.1)
buffer_bytes = self.ser.in_waiting
if buffer_bytes == 0:
print(self.ser.read(bytes))
else:
print(self.ser.read(buffer_bytes))
def wait_poll_frame(self):
data = self.xbee.wait_read_frame()
decoded_data = data['rf_data'].decode("utf-8")
parsed_data = decoded_data.replace('\n', '').split('\t')
if parsed_data[0] == '0':
return RegistrationRequest(parsed_data)
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()
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/'
#sends data to xbee address
def sendData(address, datatosend):
zb.send('tx', dest_addr_long=address, dest_addr=UNKNOWN, data=datatosend)
def recvData(data):
print data
zb = ZigBee(ser)
#test data sending method
ack = '0013A2004098DA02'
while True:
try:
sendData(WHERE, dataString)
time.sleep(0)
except KeyboardInterrupt:
break
zb.at(frame_id='A', command='MY')
reply = zb.wait_read_frame()
print(reply)
# print(zb.wait_read_frame())
zb.halt()
ser.close()
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)
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 )
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)
import serial
from xbee import XBee, ZigBee
serial_port = serial.Serial('/dev/ttyUSB0', 9600)
xbee = ZigBee(serial_port)
while True:
try:
xbee.at(command='ab')
xbee.at(command='bc')
xbee.at(command='cd')
xbee.at(command='c1')
xbee.at(command='!$')
xbee.at(command=' d')
xbee.at(command='|d')
xbee.at(command=bytes([0x13, 0x8F]))
# xbee.send('at', frame_id='B', command='DL')
except KeyboardInterrupt:
break
serial_port.close()
class handler(LoggerMixin, object):
port = None
nodes_by_identifier = {}
nodes_by_shortaddr = {}
xb = None
new_node_callbacks = []
last_discovery = 0
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()
@log_exceptions
def xbee_callback(self, *args, **kwargs):
self.logger.debug("args: {} kwargs: {}".format(args, kwargs))
packet = args[0]
node_discovery_info = None
if (packet['id'] == 'at_response' and packet['command'] == b'ND'):
node_discovery_info = packet['parameter']
if (packet['id'] == 'node_id_indicator'):
node_discovery_info = packet
node_discovery_info['node_identifier'] = packet['node_id']
if (node_discovery_info and 'node_identifier' in node_discovery_info
and 'source_addr' in node_discovery_info
and 'source_addr_long' in node_discovery_info):
# 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'],
logger_name=self.logger_name)
self.nodes_by_identifier[node.node_identifier] = node
sa_hex = binascii.hexlify(node.short_addr)
self.nodes_by_shortaddr[sa_hex] = node
self.logger.info("New node {} at 0x{}".format(
node.node_identifier, sa_hex))
# Trigger callbacks registered for new nodes
for cb in self.new_node_callbacks:
cb(node)
if packet['id'] == 'rx':
# Trigger node rx callbacks
sa_hex = binascii.hexlify(packet['source_addr'])
if sa_hex not in self.nodes_by_shortaddr:
self.logger.info(
"Got message from unkown node {}".format(sa_hex))
if time.time() - self.last_discovery > 5:
self.logger.debug("Triggering new node discovery")
self.discover_nodes()
else:
self.nodes_by_shortaddr[sa_hex].rx(packet)
@log_exceptions
def error_callback(self, *args):
self.logger.error("Got error args: {}".format(args))
try:
raise args[0]
except Exception:
self.logger.exception("Raised exception via callback")
@log_exceptions
def quit(self, *args, **kwargs):
self.xb.halt()
self.port.close()
@log_exceptions
def discover_nodes(self):
self.last_discovery = time.time()
self.xb.at(command=b'ND')
@log_exceptions
def ping_nodes(self):
"""Ping each known node to make sure it's still alive, if not mark it dead and remove from our list"""
# TODO: Implement
pass
@log_exceptions
def tx_all(self, *args):
for nodeid in self.nodes_by_identifier.keys():
self.logger.debug("Sending to {}".format(nodeid))
self.nodes_by_identifier[nodeid].tx(*args)
self.logger.debug("All sent")
@log_exceptions
def tx_string_all(self, *args):
for nodeid in self.nodes_by_identifier.keys():
self.logger.debug("Sending to {}".format(nodeid))
self.nodes_by_identifier[nodeid].tx_string(*args)
self.logger.debug("All sent")
'command': 'AO',
'parameter': b'\x03'
}
},
}
if len(sys.argv) < 2:
print "Missing command argument {}".format(commands.keys())
else:
action = sys.argv[1]
if action in commands:
XBEE_PORT = '/dev/tty.usbserial-A1014P7W'
XBEE_BAUD = 9600
ser = serial.Serial(XBEE_PORT, XBEE_BAUD)
zb = ZigBee(ser=ser,
callback=receive_message,
error_callback=xbee_error,
escaped=True)
print "Running", action, "...."
for name, command in commands[action].iteritems():
print "Sending", name
zb.at(**command)
time.sleep(3)
zb.halt()
ser.close()
else:
print "Invalid command '{}'".format(action)
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"
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"
#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)
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"
class XbeeSerial:
XbeeModules = OrderedDict()
#Cues = {}
#fireQueue = Queue.Queue(1)
ModulesLock = threading.Lock()
#CuesLock = threading.Lock()
#txEvent = threading.Event()
def __init__(self, ser):
#self.txEvent.set()
#f = open(cueFile, 'r')
#for line in f:
#line = line.strip().split(',')
#if len(line) == 2:
#self.Cues[int(line[1])] = {'name': line[0], 'adc': 0}
#f = open(XbeeFile, 'r')
#for line in f:
#line = line.strip().split(',')
#if len(line) == 2:
#line[0] = struct.pack('>Q', int(line[0], 16))
#line[1] = struct.pack('>H', int(line[1], 16))
#self.XbeeModules.append((line[0], line[1]))
self.xbee = ZigBee(ser, callback=self.callback_data)
#t = threading.Thread(target = self.loop)
#t.start()
#def loop(self):
#moduleStatus = 0
#while True:
#self.txEvent.wait(3)
#try:
#fireCue = self.fireQueue.get(False)
#except Queue.Empty:
#fireCue = -1
#if fireCue < 0:
#pass
#if moduleStatus >= len(self.XbeeModules):
# moduleStatus = 0
#self.updateStatus(moduleStatus)
#moduleStatus += 1
#else:
#self.fire(fireCue)
def initialize(self):
with self.ModulesLock:
self.XbeeModules = OrderedDict()
self.xbee.at(command = 'ND')
return {'message': 'Initializing...'}
def getBoardInfo(self, addr_long, addr):
#print('Getting board info {0} {1}'.format(addr_long, addr))
self.tx_addr(addr_long, addr, 'i')
#def addFire(self, cue):
# self.fireQueue.put(cue)
def fire(self, cue):
with self.ModulesLock:
for i, (board_id, (addr_long, addr, num_cues)) in enumerate(self.XbeeModules.iteritems()):
if cue < num_cues:
board = board_id
break
else:
cue -= num_cues
else:
return
print('%s - Fireing cue: %d on board: %d' % (datetime.now(), cue, board))
self.tx_board(board, 'f%c' % cue)
#def getStatus(self):
#with self.CuesLock:
#return self.Cues
def getStatus(self):
cues=[]
with self.ModulesLock:
for i, (board_id, (addr_long, addr, num_cues)) in enumerate(self.XbeeModules.iteritems()):
for cue in range(0, num_cues):
cues.append({'name': 'Board: %d, Cue: %d' % (board_id, cue), 'adc': 500});
return cues
def tx_board(self, board, data):
with self.ModulesLock:
self.tx_addr(self.XbeeModules[board][0], self.XbeeModules[board][1], data)
def tx_addr(self, addr_long, addr, data):
#self.txEvent.clear()
self.xbee.tx(dest_addr_long = addr_long, dest_addr = addr, data = data)
def callback_data(self, data):
if data['id'] == 'rx':
if len(data['rf_data']) > 0:
if data['rf_data'][0] == 'I' and len(data['rf_data']) == 3:
#print('board_id: {0} 64: {1} 16: {2} cues: {3}'.format(ord(data['rf_data'][1]), data['source_addr_long'], data['source_addr'], ord(data['rf_data'][2])))
with self.ModulesLock:
self.XbeeModules[ord(data['rf_data'][1])] = (data['source_addr_long'], data['source_addr'], ord(data['rf_data'][2]))
self.XbeeModules = OrderedDict(sorted(self.XbeeModules.items()))
#print(self.XbeeModules)
#else:
#print(data)
#self.txEvent.set()
#for (i, module) in enumerate(self.XbeeModules):
#if data['source_addr_long'] == module[0] and data['source_addr'] == module[1]:
#moduleNum = i
#break;
#else:
#print('%s - unknown module' % datetime.today())
#return
#if data['rf_data'][0] != '[':
#status = data['rf_data'].split(',')
#with self.CuesLock:
#for i in range(0, len(status), 2):
#cue = int(status[i]) + 20 * moduleNum
#if cue in self.Cues:
#self.Cues[cue]['adc'] = status[i + 1]
#print('%s - status from module %d' % (datetime.now(), moduleNum))
#else:
#print('%s - response from module %d' % (datetime.now(), moduleNum))
elif data['id'] == 'at_response' and data['command'] == 'ND':
#print(data)
if data['parameter']['device_type'] == '\x01':
self.getBoardInfo(data['parameter']['source_addr_long'], data['parameter']['source_addr'])
