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