def fetch_rssi(socket, bdaddr):
flt = bluez.hci_filter_new()
bluez.hci_filter_all_events(flt)
bluez.hci_filter_set_ptype(flt, bluez.HCI_EVENT_PKT)
socket.setsockopt( bluez.SOL_HCI, bluez.HCI_FILTER, flt )
cmd_pkt = struct.pack("????")
bluez.hci_send_cmd(socket, bluez.OGF_LINK_CTL, bluez.OCF_READ_RSSI, cmd_pkt)
pkt = socket.recv(255)
ptype, event, plen = struct.unpack("BBB", pkt[:3])
if event == bluez.EVT_INQUIRY_RESULT_WITH_RSSI:
pkt = pkt[3:]
nrsp = bluetooth.get_byte(pkt[0])
for i in range(nrsp):
addr = bluez.ba2str( pkt[1+6*i:1+6*i+6] )
rssi = bluetooth.byte_to_signed_int(
bluetooth.get_byte(pkt[1+13*nrsp+i]))
results.append( ( addr, rssi ) )
print("[%s] RSSI: [%d]" % (addr, rssi))
elif event == bluez.EVT_CMD_STATUS:
status, ncmd, opcode = struct.unpack("BBH", pkt[3:7])
if status != 0:
print("uh oh...")
done = True
elif event == bluez.EVT_INQUIRY_RESULT:
pkt = pkt[3:]
nrsp = bluetooth.get_byte(pkt[0])
for i in range(nrsp):
addr = bluez.ba2str( pkt[1+6*i:1+6*i+6] )
results.append( ( addr, -1 ) )
print("[%s] (no RRSI)" % addr)
else:
print("unrecognized packet type 0x%02x" % ptype)
print("event ", event)
def device_inquiry_with_with_rssi(sock):
global FOUND
# save current filter
old_filter = sock.getsockopt( bluez.SOL_HCI, bluez.HCI_FILTER, 14)
# perform a device inquiry on bluetooth device #0
# The inquiry should last 8 * 1.28 = 10.24 seconds
# before the inquiry is performed, bluez should flush its cache of
# previously discovered devices
flt = bluez.hci_filter_new()
bluez.hci_filter_all_events(flt)
bluez.hci_filter_set_ptype(flt, bluez.HCI_EVENT_PKT)
sock.setsockopt( bluez.SOL_HCI, bluez.HCI_FILTER, flt )
duration = 4
max_responses = 255
cmd_pkt = struct.pack("BBBBB", 0x33, 0x8b, 0x9e, duration, max_responses)
bluez.hci_send_cmd(sock, bluez.OGF_LINK_CTL, bluez.OCF_INQUIRY, cmd_pkt)
results = []
done = False
while not done:
pkt = sock.recv(255)
ptype, event, plen = struct.unpack("BBB", pkt[:3])
if event == bluez.EVT_INQUIRY_RESULT_WITH_RSSI:
pkt = pkt[3:]
nrsp = struct.unpack("B", pkt[0])[0]
for i in range(nrsp):
addr = bluez.ba2str( pkt[1+6*i:1+6*i+6] )
rssi = struct.unpack("b", pkt[1+13*nrsp+i])[0]
results.append( ( addr, rssi ) )
print("[%s] RSSI: [%d]" % (addr, rssi))
if addr == ADDR:
FOUND = True
return
elif event == bluez.EVT_INQUIRY_COMPLETE:
done = True
elif event == bluez.EVT_CMD_STATUS:
status, ncmd, opcode = struct.unpack("BBH", pkt[3:7])
if status != 0:
print("uh oh...")
printpacket(pkt[3:7])
done = True
elif event == bluez.EVT_INQUIRY_RESULT:
pkt = pkt[3:]
nrsp = struct.unpack("B", pkt[0])[0]
for i in range(nrsp):
addr = bluez.ba2str( pkt[1+6*i:1+6*i+6] )
results.append( ( addr, -1 ) )
print("[%s] (no RRSI)" % addr)
else:
print("unrecognized packet type 0x%02x" % ptype)
print("event ", event)
# restore old filter
sock.setsockopt( bluez.SOL_HCI, bluez.HCI_FILTER, old_filter )
return results
def device_inquiry_with_with_rssi(sock):
# save current filter
old_filter = sock.getsockopt(bluez.SOL_HCI, bluez.HCI_FILTER, 14)
# perform a device inquiry on bluetooth device #0
# The inquiry should last 8 * 1.28 = 10.24 seconds
# before the inquiry is performed, bluez should flush its cache of
# previously discovered devices
flt = bluez.hci_filter_new()
bluez.hci_filter_all_events(flt)
bluez.hci_filter_set_ptype(flt, bluez.HCI_EVENT_PKT)
sock.setsockopt(bluez.SOL_HCI, bluez.HCI_FILTER, flt)
duration = 4
max_responses = 255
cmd_pkt = struct.pack("BBBBB", 0x33, 0x8b, 0x9e, duration, max_responses)
bluez.hci_send_cmd(sock, bluez.OGF_LINK_CTL, bluez.OCF_INQUIRY, cmd_pkt)
results = []
while True:
pkt = sock.recv(255)
ptype, event, plen = struct.unpack("BBB", pkt[:3])
print("Event: {}".format(event))
if event == bluez.EVT_INQUIRY_RESULT_WITH_RSSI:
pkt = pkt[3:]
nrsp = bluetooth.get_byte(pkt[0])
for i in range(nrsp):
addr = bluez.ba2str(pkt[1 + 6 * i:1 + 6 * i + 6])
rssi = bluetooth.byte_to_signed_int(
bluetooth.get_byte(pkt[1 + 13 * nrsp + i]))
results.append((addr, rssi))
print("[{}] RSSI: {}".format(addr, rssi))
rssi = (pkt[-1])
print(addr, rssi)
elif event == bluez.EVT_INQUIRY_COMPLETE:
break
elif event == bluez.EVT_CMD_STATUS:
status, ncmd, opcode = struct.unpack("BBH", pkt[3:7])
if status:
print("Uh oh...")
printpacket(pkt[3:7])
break
elif event == bluez.EVT_INQUIRY_RESULT:
pkt = pkt[3:]
nrsp = bluetooth.get_byte(pkt[0])
for i in range(nrsp):
addr = bluez.ba2str(pkt[1 + 6 * i:1 + 6 * i + 6])
results.append((addr, -1))
print("[{}] (no RRSI)".format(addr))
rssi = (pkt[-1])
print(addr, rssi)
else:
print("Unrecognized packet type 0x{:02x}.".format(ptype))
# restore old filter
sock.setsockopt(bluez.SOL_HCI, bluez.HCI_FILTER, old_filter)
return results
def process_event(self):
if not self.inquiring:
return
# Leer 258 bytes (tamaño máximo: 3 cabecera + 255 datos)
pkt = self.socket.recv(258)
ptype, event, plen = struct.unpack("BBB", pkt[:3])
pkt = pkt[3:] # Obtiene el payload (quitando cabecera)
if event == bluez.EVT_INQUIRY_RESULT_WITH_RSSI:
nrsp = struct.unpack("B", pkt[0])[0] # Número de respuestas
for i in range(nrsp):
# Obtiene la dirección dispositivo
addr = bluez.ba2str(pkt[1+6*i:1+6*i+6])
# Obtiene el rssi
rssi = struct.unpack("b", pkt[1+13*nrsp+i])[0]
# print addr, rssi
# r = -0.00680102923817849*(int(rssi)**3) -
# 1.04905123190747*(int(rssi)**2) - 59.2087843354658*int(rssi)
# - 1106.35595941215
# print r
rssi = float(rssi)
#if addr[0:5] == self.addr_nino or addr[0:5] == self.addr_nino1:
# Organiza los valores recibidos,eliminar errores,
# y envia un valor RSSI
rssi_bueno = self.procesamiento(addr, rssi)
return rssi_bueno
elif event == bluez.EVT_INQUIRY_COMPLETE:
pass
# self.socket.close()
# self.socket = None
# self.inquiring = False
elif event == bluez.EVT_CMD_STATUS:
status, ncmd, opcode = struct.unpack("BBH", pkt[:4])
if status != 0:
print "[Bluetooth] Dispositivo ocupado"
self.socket.close()
self.socket = None
self.inquiring = False
elif event == bluez.EVT_CMD_COMPLETE:
pass
elif event == 255:
# Suponemos que no lee ningun evento y por eso devuelve 255
return
elif event == bluez.EVT_INQUIRY_RESULT:
nrsp = struct.unpack("B", pkt[0])[0] # Número de respuestas
for i in range(nrsp):
addr = bluez.ba2str(pkt[1+6*i:1+6*i+6])
print "[Bluetooth] %s (no RRSI)" % addr
else:
self.inquiring = False
self.socket = None
self.socket.close()
print "[Bluetooth] Evento desconocido: ", event
def _device_inquiry_with_with_rssi(self, sock):
"""inquiry blutooth devices with rssi"""
# save current filter
old_filter = sock.getsockopt(bluez.SOL_HCI, bluez.HCI_FILTER, 14)
# perform a device inquiry on bluetooth device #0
# The inquiry should last 8 * 1.28 = 10.24 seconds
# before the inquiry is performed, bluez should flush its cache of
# previously discovered devices
flt = bluez.hci_filter_new()
bluez.hci_filter_all_events(flt)
bluez.hci_filter_set_ptype(flt, bluez.HCI_EVENT_PKT)
sock.setsockopt(bluez.SOL_HCI, bluez.HCI_FILTER, flt)
duration = 4
max_responses = 255
cmd_pkt = struct.pack("BBBBB", 0x33, 0x8b, 0x9e, duration,
max_responses)
bluez.hci_send_cmd(sock, bluez.OGF_LINK_CTL, bluez.OCF_INQUIRY,
cmd_pkt)
results = []
done = False
while not done:
pkt = sock.recv(255)
ptype, event, plen = struct.unpack("BBB", pkt[:3])
if event == bluez.EVT_INQUIRY_RESULT_WITH_RSSI:
pkt = pkt[3:]
nrsp = bluetooth.get_byte(pkt[0])
for i in range(nrsp):
addr = bluez.ba2str(pkt[1 + 6 * i:1 + 6 * i + 6])
rssi = bluetooth.byte_to_signed_int(
bluetooth.get_byte(pkt[1 + 13 * nrsp + i]))
results.append(
(addr, rssi, str(datetime.datetime.utcnow())))
elif event == bluez.EVT_INQUIRY_COMPLETE:
done = True
elif event == bluez.EVT_CMD_STATUS:
status, ncmd, opcode = struct.unpack("BBH", pkt[3:7])
if status != 0:
print("uh oh...")
self._print_packet(pkt[3:7])
done = True
elif event == bluez.EVT_INQUIRY_RESULT:
pkt = pkt[3:]
nrsp = bluetooth.get_byte(pkt[0])
for i in range(nrsp):
addr = bluez.ba2str(pkt[1 + 6 * i:1 + 6 * i + 6])
results.append((addr, -1, str(datetime.datetime.utcnow())))
else:
print("unrecognized packet type 0x%02x" % ptype)
# restore old filter
sock.setsockopt(bluez.SOL_HCI, bluez.HCI_FILTER, old_filter)
return results
def device_inquiry_with_with_rssi(sock):
# save current filter
old_filter = sock.getsockopt( bluez.SOL_HCI, bluez.HCI_FILTER, 14)
# perform a device inquiry on bluetooth device #0
# The inquiry should last 8 * 1.28 = 10.24 seconds
# before the inquiry is performed, bluez should flush its cache of
# previously discovered devices
flt = bluez.hci_filter_new()
bluez.hci_filter_all_events(flt)
bluez.hci_filter_set_ptype(flt, bluez.HCI_EVENT_PKT)
sock.setsockopt( bluez.SOL_HCI, bluez.HCI_FILTER, flt )
duration = 4
max_responses = 255
cmd_pkt = struct.pack("BBBBB", 0x33, 0x8b, 0x9e, duration, max_responses)
bluez.hci_send_cmd(sock, bluez.OGF_LINK_CTL, bluez.OCF_INQUIRY, cmd_pkt)
results = []
done = False
while not done:
pkt = sock.recv(255)
ptype, event, plen = struct.unpack("BBB", pkt[:3])
if event == bluez.EVT_INQUIRY_RESULT_WITH_RSSI:
pkt = pkt[3:]
print("test", pkt, type(pkt[0]))
nrsp = struct.unpack(b"B", bytes(pkt[0]))[0]
print(nrsp, type(nrsp))
for i in range(nrsp):
addr = bluez.ba2str( pkt[1+6*i:1+6*i+6] )
rssi = struct.unpack("b", pkt[1+13*nrsp+i])[0]
print("addr", addr, type(addr))
results.append( ( addr, rssi ) )
print ("[%s] RSSI: [%d]" % (addr, rssi))
elif event == bluez.EVT_INQUIRY_COMPLETE:
done = True
elif event == bluez.EVT_CMD_STATUS:
status, ncmd, opcode = struct.unpack("BBH", pkt[3:7])
if status != 0:
print ("uh oh...")
printpacket(pkt[3:7])
done = True
elif event == bluez.EVT_INQUIRY_RESULT:
pkt = pkt[3:]
nrsp = struct.unpack("B", pkt[0])[0]
for i in range(nrsp):
addr = bluez.ba2str( pkt[1+6*i:1+6*i+6] )
results.append( ( addr, -1 ) )
print ("[%s] (no RRSI)" % addr)
else:
print ("unrecognized packet type 0x%02x" % ptype)
print ("event ", event)
# restore old filter
sock.setsockopt( bluez.SOL_HCI, bluez.HCI_FILTER, old_filter )
return results
def device_inquiry_with_with_rssi(sock):
# save current filter
old_filter = sock.getsockopt( bluez.SOL_HCI, bluez.HCI_FILTER, 14)
# perform a device inquiry on bluetooth device #0
# The inquiry should last 8 * 1.28 = 10.24 seconds
# before the inquiry is performed, bluez should flush its cache of
# previously discovered devices
flt = bluez.hci_filter_new()
bluez.hci_filter_all_events(flt)
bluez.hci_filter_set_ptype(flt, bluez.HCI_EVENT_PKT)
sock.setsockopt( bluez.SOL_HCI, bluez.HCI_FILTER, flt )
duration = 4
max_responses = 255
cmd_pkt = struct.pack("BBBBB", 0x33, 0x8b, 0x9e, duration, max_responses)
bluez.hci_send_cmd(sock, bluez.OGF_LINK_CTL, bluez.OCF_INQUIRY, cmd_pkt)
results = []
done = False
while not done:
pkt = sock.recv(255)
__, event, __ = struct.unpack("BBB", pkt[:3])
if event == bluez.EVT_INQUIRY_RESULT_WITH_RSSI:
pkt = pkt[3:]
nrsp = bluetooth.get_byte(pkt[0])
for i in range(nrsp):
addr = bluez.ba2str( pkt[1+6*i:1+6*i+6] )
rssi = bluetooth.byte_to_signed_int(
bluetooth.get_byte(pkt[1+13*nrsp+i]))
results.append( ( addr, rssi ) )
elif event == bluez.EVT_INQUIRY_COMPLETE:
done = True
elif event == bluez.EVT_CMD_STATUS:
status, __, __ = struct.unpack("BBH", pkt[3:7])
if status != 0:
done = True
elif event == bluez.EVT_INQUIRY_RESULT:
pkt = pkt[3:]
nrsp = bluetooth.get_byte(pkt[0])
for i in range(nrsp):
addr = bluez.ba2str( pkt[1+6*i:1+6*i+6] )
results.append( ( addr, -1 ) )
# restore old filter
sock.setsockopt( bluez.SOL_HCI, bluez.HCI_FILTER, old_filter )
return results
def search_device(sess, target_name):
sess.bluetoothSocket.send("\x01\x0c\x20\x02\x01\x00") #Enable LE scan
results = []
done = False
while not done:
pkt = sess.bluetoothSocket.recv(255)
ptype, event, plen = struct.unpack("BBB", pkt[:3])
if event == 62:
pkt = pkt[3:]
nrsp = pybluez.get_byte(pkt[0])
for i in range(nrsp):
addr = bluez.ba2str(pkt[4 + 6 * i:4 + 6 * i + 6])
if target_name in pkt:
print(" %s found with mac %s" % (target_name, addr))
sess.bluetoothSocket.send(
"\x01\x0c\x20\x02\x00\x00") #Disable LE scan
done = True
time.sleep(2)
return pkt[4 + 6 * i:4 + 6 * i + 6] #Return as hex
results.append((addr, -1))
print("[%s] (no RRSI)" % addr)
else:
print("unrecognized packet type 0x%02x" % ptype)
def process_event(self):
if self.inquiring == False:
return
# Leer 258 bytes (tamaño máximo: 3 cabecera + 255 datos)
pkt = self.socket.recv(258)
ptype, event, plen = struct.unpack("BBB", pkt[:3])
pkt = pkt[3:] # Obtiene el payload (quitando cabecera)
if event == bluez.EVT_INQUIRY_RESULT_WITH_RSSI:
nrsp = struct.unpack("B", pkt[0])[0] # Número de respuestas
for i in range(nrsp):
# Obtiene la dirección dispositivo
addr = bluez.ba2str( pkt[1+6*i:1+6*i+6] )
if addr != self.mac:
continue
# Obtiene el rssi
rssi = struct.unpack("b", pkt[1+13*nrsp+i])[0]
self.samples.append(rssi)
elif event == bluez.EVT_INQUIRY_COMPLETE:
self.socket.close()
self.socket = None
self.inquiring = False
elif event == bluez.EVT_CMD_STATUS:
status, ncmd, opcode = struct.unpack("BBH", pkt[:4])
if status != 0:
print "Dispositivo ocupado"
self.socket.close()
self.socket = None
self.inquiring = False
elif event == bluez.EVT_INQUIRY_RESULT:
nrsp = struct.unpack("B", pkt[0])[0] # Número de respuestas
for i in range(nrsp):
addr = bluez.ba2str( pkt[1+6*i:1+6*i+6] )
if addr != self.mac:
continue
print "%s (no RRSI)" % addr
else:
print "Evento desconocido: ", event
def _handle_inquiry_result_with_rssi(pkt):
result = {}
num_inquiry_results = struct.unpack("B", pkt[0])[0]
pkt = pkt[1:]
result["num_inquiry_results"] = num_inquiry_results
result["inquiry_results"] = []
for i in xrange(num_inquiry_results):
addr = bluez.ba2str(pkt[(6 * i):(6 * i) + 6])
rssi = struct.unpack("b", pkt[(13 * num_inquiry_results) + i])[0]
result["inquiry_results"].append({"Address": addr, "RSSI": rssi})
return result
def device_inquiry_with_with_rssi(sock, wanted_addr):
global results
# save current filter
old_filter = sock.getsockopt( bluez.SOL_HCI, bluez.HCI_FILTER, 14)
# perform a device inquiry on bluetooth device #0
# The inquiry should last 8 * 1.28 = 10.24 seconds
# before the inquiry is performed, bluez should flush its cache of
# previously discovered devices
flt = bluez.hci_filter_new()
bluez.hci_filter_all_events(flt)
bluez.hci_filter_set_ptype(flt, bluez.HCI_EVENT_PKT)
sock.setsockopt( bluez.SOL_HCI, bluez.HCI_FILTER, flt )
duration = 4
max_responses = 255
# 0x9e8b33 is the reserved code for general inquiry of Bluetooth devices
cmd_pkt = struct.pack("BBBBB", 0x33, 0x8b, 0x9e, duration, max_responses)
bluez.hci_send_cmd(sock, bluez.OGF_LINK_CTL, bluez.OCF_INQUIRY, cmd_pkt)
done = False
while not done:
pkt = sock.recv(255)
ptype, event, plen = struct.unpack("BBB", pkt[:3])
if event == bluez.EVT_INQUIRY_RESULT_WITH_RSSI:
pkt = pkt[3:]
nrsp = struct.unpack("B", pkt[0])[0]
for i in range(nrsp):
addr = bluez.ba2str( pkt[1+6*i:1+6*i+6] )
rssi = struct.unpack("b", pkt[1+13*nrsp+i])[0]
if addr == wanted_addr:
results.append( rssi )
# print "*** ",
# print "[%s] RSSI: [%d]" % (addr, rssi)
elif event == bluez.EVT_INQUIRY_COMPLETE:
done = True
elif event == bluez.EVT_CMD_STATUS:
status, ncmd, opcode = struct.unpack("BBH", pkt[3:7])
if status != 0:
print "uh oh..."
done = True
else:
# print "unrecognized packet type 0x%02x" % ptype
continue
# restore old filter
sock.setsockopt( bluez.SOL_HCI, bluez.HCI_FILTER, old_filter )
if len(results) > 10:
results = results[-10:]
return results
def device_inquiry_with_with_rssi(sock, wanted_addr):
global results
# save current filter
old_filter = sock.getsockopt(bluez.SOL_HCI, bluez.HCI_FILTER, 14)
# perform a device inquiry on bluetooth device #0
# The inquiry should last 8 * 1.28 = 10.24 seconds
# before the inquiry is performed, bluez should flush its cache of
# previously discovered devices
flt = bluez.hci_filter_new()
bluez.hci_filter_all_events(flt)
bluez.hci_filter_set_ptype(flt, bluez.HCI_EVENT_PKT)
sock.setsockopt(bluez.SOL_HCI, bluez.HCI_FILTER, flt)
duration = 4
max_responses = 255
# 0x9e8b33 is the reserved code for general inquiry of Bluetooth devices
cmd_pkt = struct.pack("BBBBB", 0x33, 0x8b, 0x9e, duration, max_responses)
bluez.hci_send_cmd(sock, bluez.OGF_LINK_CTL, bluez.OCF_INQUIRY, cmd_pkt)
done = False
while not done:
pkt = sock.recv(255)
ptype, event, plen = struct.unpack("BBB", pkt[:3])
if event == bluez.EVT_INQUIRY_RESULT_WITH_RSSI:
pkt = pkt[3:]
nrsp = struct.unpack("B", pkt[0])[0]
for i in range(nrsp):
addr = bluez.ba2str(pkt[1 + 6 * i:1 + 6 * i + 6])
rssi = struct.unpack("b", pkt[1 + 13 * nrsp + i])[0]
if addr == wanted_addr:
results.append(rssi)
# print "*** ",
# print "[%s] RSSI: [%d]" % (addr, rssi)
elif event == bluez.EVT_INQUIRY_COMPLETE:
done = True
elif event == bluez.EVT_CMD_STATUS:
status, ncmd, opcode = struct.unpack("BBH", pkt[3:7])
if status != 0:
print "uh oh..."
done = True
else:
# print "unrecognized packet type 0x%02x" % ptype
continue
# restore old filter
sock.setsockopt(bluez.SOL_HCI, bluez.HCI_FILTER, old_filter)
if len(results) > 10:
results = results[-10:]
return results
def bt_print_device_inquiry_list(sock):
""" void """
# save current filter
old_filter = sock.getsockopt(bluez.SOL_HCI, bluez.HCI_FILTER, 14)
# perform a device inquiry on bluetooth device #0
# The inquiry should last 8 * 1.28 = 10.24 seconds
# before the inquiry is performed, bluez should flush its cache of
# previously discovered devices
flt = bluez.hci_filter_new()
bluez.hci_filter_all_events(flt)
bluez.hci_filter_set_ptype(flt, bluez.HCI_EVENT_PKT)
sock.setsockopt(bluez.SOL_HCI, bluez.HCI_FILTER, flt)
duration = 16
max_responses = 255
cmd_pkt = struct.pack("BBBBB", 0x33, 0x8b, 0x9e, duration, max_responses)
bluez.hci_send_cmd(sock, bluez.OGF_LINK_CTL, bluez.OCF_INQUIRY, cmd_pkt)
results = []
done = False
while not done:
pkt = sock.recv(255)
ptype, event, plen = struct.unpack("BBB", pkt[:3])
if event == bluez.EVT_INQUIRY_RESULT_WITH_RSSI:
pkt = pkt[3:]
nrsp = struct.unpack("B", pkt[0])[0]
for i in range(nrsp):
addr = bluez.ba2str(pkt[1 + 6 * i:1 + 6 * i + 6])
rssi = struct.unpack("b", pkt[1 + 13 * nrsp + i])[0]
results.append(addr)
elif event == bluez.EVT_INQUIRY_COMPLETE:
done = True
elif event == bluez.EVT_CMD_STATUS:
status, ncmd, opcode = struct.unpack("BBH", pkt[3:7])
if status != 0:
done = True
else:
print "unrecognized packet type 0x%02x" % ptype
# restore old filter
sock.setsockopt(bluez.SOL_HCI, bluez.HCI_FILTER, old_filter)
# Results become unique
set = {}
map(set.__setitem__, results, [])
print set.keys()
def inquiry_with_rssi(self):
cmd_pkt = HCIInquiry(0x9e8b33, 4, 255)
self.send_hci_cmd(cmd_pkt)
results = []
done = False
while not done:
evt = self.recv_hci_evt()
if evt.code == bluez.EVT_INQUIRY_RESULT_WITH_RSSI:
for i in xrange(evt.num_responses):
addr = bluez.ba2str(evt.bd_addr[i])
rssi = evt.rssi[i]
results.append( ( addr, rssi ) )
print "[{}] RSSI: [{}]".format(addr, rssi)
elif evt.code == bluez.EVT_INQUIRY_COMPLETE:
done = True
elif evt.code == bluez.EVT_CMD_STATUS:
if evt.status != 0:
print "uh oh..."
done = True
else:
print "unrecognized event: {}".format(evt)
def _handle_inquiry_result(pkt):
result = {}
num_inquiry_results = struct.unpack("B", pkt[0])[0]
pkt = pkt[1:]
result["num_inquiry_results"] = num_inquiry_results
result["inquiry_results"] = []
for i in xrange(num_inquiry_results):
addr = bluez.ba2str(pkt[(6 * i):(6 * i) + 6])
result["inquiry_results"].append({"Address": addr})
return result
num_connection_handles = struct.unpack("<B", pkt[0])[0]
pkt = pkt[1:]
result["num_connection_handles"] = num_connection_handles
result["handles"] = []
for i in xrange(num_connection_handles):
handle, = struct.unpack("<H", pkt[0:2])
completed_packets, = struct.unpack("<H", pkt[2:4])
result["handles"].append(
{"handle": handle, "num_completed_packets": completed_packets})
pkt = pkt[4:]
return result
def device_inquiry_with_with_rssi(sock):
# save current filter
old_filter = sock.getsockopt( bluez.SOL_HCI, bluez.HCI_FILTER, 14)
# perform a device inquiry on bluetooth device #0
# The inquiry should last 8 * 1.28 = 10.24 seconds
# before the inquiry is performed, bluez should flush its cache of
# previously discovered devices
flt = bluez.hci_filter_new()
bluez.hci_filter_all_events(flt)
bluez.hci_filter_set_ptype(flt, bluez.HCI_EVENT_PKT)
sock.setsockopt( bluez.SOL_HCI, bluez.HCI_FILTER, flt )
#filter
duration = 4
max_responses = 255
cmd_pkt = struct.pack("BBBBB", 0x33, 0x8b, 0x9e, duration, max_responses)
bluez.hci_send_cmd(sock, bluez.OGF_LINK_CTL, bluez.OCF_INQUIRY, cmd_pkt)
#send command
results = []
done = False
while not done:
pkt = sock.recv(255)
ptype, event, plen = struct.unpack("BBB", pkt[:3])
if event == bluez.EVT_INQUIRY_RESULT_WITH_RSSI:
pkt = pkt[3:]
nrsp = bluetooth.get_byte(pkt[0])
for i in range(nrsp):
addr = bluez.ba2str( pkt[1+6*i:1+6*i+6] )
rssi = bluetooth.byte_to_signed_int(
bluetooth.get_byte(pkt[1+13*nrsp+i]))
results.append( ( addr, rssi ) )# store rssi and mac
print("[%s] RSSI: [%d]" % (addr, rssi))
elif event == bluez.EVT_INQUIRY_COMPLETE:
#scanning complete
done = True
def _device_inquiry_with_with_rssi(self):
"""
Perform a Bluetooth inquiry with RSSI reception.
"""
# save current filter
old_filter = self.sock.getsockopt(bluez.SOL_HCI, bluez.HCI_FILTER, 14)
flt = bluez.hci_filter_new()
bluez.hci_filter_all_events(flt)
bluez.hci_filter_set_ptype(flt, bluez.HCI_EVENT_PKT)
self.sock.setsockopt(bluez.SOL_HCI, bluez.HCI_FILTER, flt)
max_responses = 255
cmd_pkt = struct.pack("BBBBB", 0x33, 0x8b, 0x9e, self.buffer_size,
max_responses)
self.logger_inquiry.write(time.time(), self.buffer_size * 1.28)
self.mgr.debug("%s: New inquiry" % self.mac)
bluez.hci_send_cmd(self.sock, bluez.OGF_LINK_CTL, bluez.OCF_INQUIRY,
cmd_pkt)
done = False
while not done:
try:
pkt = self.sock.recv(255)
except bluetooth._bluetooth.error, e:
if e[0] == 32:
self.logger.stop()
done = True
self.done = True
self.scanner.stopped_scanning(self, "adapter lost")
return
ptype, event, plen = struct.unpack("BBB", pkt[:3])
if event == bluez.EVT_INQUIRY_RESULT_WITH_RSSI:
pkt = pkt[3:]
nrsp = struct.unpack("B", pkt[0])[0]
for i in range(nrsp):
addr = bluez.ba2str(pkt[1 + 6 * i:1 + 6 * i + 6])
rssi = struct.unpack("b", pkt[1 + 13 * nrsp + i])[0]
devclass_raw = pkt[1 + 8 * nrsp + 3 * i:1 + 8 * nrsp +
3 * i + 3]
devclass = struct.unpack("I", "%s\0" % devclass_raw)[0]
self.device_discovered(addr, devclass, rssi)
elif event == bluez.EVT_INQUIRY_RESULT:
pkt = pkt[3:]
nrsp = struct.unpack("B", pkt[0])[0]
for i in range(nrsp):
addr = bluez.ba2str(pkt[1 + 6 * i:1 + 6 * i + 6])
devclass_raw = struct.unpack(
"BBB",
pkt[1 + 9 * nrsp + 3 * i:1 + 9 * nrsp + 3 * i + 3])
devclass = (devclass_raw[2] << 16) | \
(devclass_raw[1] << 8) | \
devclass_raw[0]
self.device_discovered(addr, devclass, None)
elif event == bluez.EVT_INQUIRY_COMPLETE:
done = True
elif event == bluez.EVT_CMD_STATUS:
status, ncmd, opcode = struct.unpack("BBH", pkt[3:7])
if status != 0:
self.mgr.debug('Non-zero Bluetooth status packet received')
done = True
else:
self.mgr.debug('Unrecognized Bluetooth packet type received')
def parse_events(sock, loop_count=100):
old_filter = sock.getsockopt( bluez.SOL_HCI, bluez.HCI_FILTER, 14)
# perform a device inquiry on bluetooth device #0
# The inquiry should last 8 * 1.28 = 10.24 seconds
# before the inquiry is performed, bluez should flush its cache of
# previously discovered devices
flt = bluez.hci_filter_new()
bluez.hci_filter_all_events(flt)
bluez.hci_filter_set_ptype(flt, bluez.HCI_EVENT_PKT)
sock.setsockopt( bluez.SOL_HCI, bluez.HCI_FILTER, flt )
done = False
results = []
for i in range(0, loop_count):
pkt = sock.recv(255)
ptype, event, plen = struct.unpack("BBB", pkt[:3])
print "-------------- ptype: 0x%02x event: 0x%02x plen: 0x%02x" % (ptype, event, plen)
if event == bluez.EVT_INQUIRY_RESULT_WITH_RSSI:
pkt = pkt[3:]
nrsp = struct.unpack("B", pkt[0])[0]
for i in range(nrsp):
addr = bluez.ba2str( pkt[1+6*i:1+6*i+6] )
rssi = struct.unpack("b", pkt[1+13*nrsp+i])[0]
results.append( ( addr, rssi ) )
print "Inquiry: [%s] RSSI: [%d]" % (addr, rssi)
elif event == bluez.EVT_NUM_COMP_PKTS:
print "num completed packets"
pkt = pkt[3:]
num_connection_handles = struct.unpack("B", pkt[0])[0]
pkt = pkt[1:]
print "handles:", num_connection_handles
for i in range(0, num_connection_handles):
handle, = struct.unpack("H", pkt[0:2])
completed_packets, = struct.unpack("H", pkt[2:4])
print "\thandle: 0x%04x completed packets: 0x%04x" % (handle, completed_packets)
pkt = pkt[4:]
elif event == bluez.EVT_DISCONN_COMPLETE:
pkt = pkt[3:]
status, handle, reason = struct.unpack("<BHB", pkt)
print "Disconnected, status: 0x%02x handle: 0x%04x reason: 0x%02x" % (status, handle, reason)
elif event == LE_META_EVENT:
subevent, = struct.unpack("B", pkt[3])
pkt = pkt[4:]
print "LE META EVENT subevent: 0x%02x" %(subevent,)
if subevent == EVT_LE_CONN_COMPLETE:
print "connection complete"
le_handle_connection_complete(pkt)
elif subevent == EVT_LE_ADVERTISING_REPORT:
print "advertising report"
num_reports = struct.unpack("B", pkt[0])[0]
report_pkt_offset = 0
print "Number of reports in the report: 0x%02x" % num_reports
for i in range(0, num_reports):
print "report", i
report_event_type = struct.unpack("B", pkt[report_pkt_offset + 1])[0]
bdaddr_type = struct.unpack("B", pkt[report_pkt_offset + 2])[0]
print "\tadvertising report event type: 0x%02x" % report_event_type
print "\tbdaddr type: 0x%02x" % (bdaddr_type,)
print "\tdevice address: ", packed_bdaddr_to_string(pkt[report_pkt_offset + 3:report_pkt_offset + 9])
report_data_length, = struct.unpack("B", pkt[report_pkt_offset + 9])
print "\tadvertising packet metadata length: ", report_data_length
if report_event_type == ADV_IND:
print "\tADV_IND"
elif report_event_type == ADV_DIRECT_IND:
print "\tADV_DIRECT_IND"
elif report_event_type == ADV_SCAN_IND:
print "\tADV_SCAN_IND"
elif report_event_type == ADV_NONCONN_IND:
print "\tADV_NONCONN_IND"
elif report_event_type == ADV_SCAN_RSP:
print "\tADV_SCAN_RSP"
local_name_len, = struct.unpack("B", pkt[report_pkt_offset + 11])
name = pkt[report_pkt_offset + 12:report_pkt_offset + 12+local_name_len]
print "\tname:", name
else:
print "\tUnknown or reserved event type"
# each report is 2 (event type, bdaddr type) + 6 (the address)
# + 1 (data length field) + data length + 1 (rssi)
report_pkt_offset = report_pkt_offset + 10 + report_data_length + 1
rssi, = struct.unpack("b", pkt[report_pkt_offset -1])
print "\tRSSI:", rssi
#for i in range(nrsp):
# addr = bluez.ba2str( pkt[1+6*i:1+6*i+6] )
# rssi = struct.unpack("b", pkt[1+13*nrsp+i])[0]
# results.append( ( addr, rssi ) )
# print "Meta: [%s] RSSI: [%d]" % (addr, rssi)
elif subevent == EVT_LE_CONN_UPDATE_COMPLETE:
print "connection updated"
printpacket(pkt)
elif subevent == EVT_LE_READ_REMOTE_USED_FEATURES_COMPLETE:
print "read remote used features complete"
else:
print "unknown LE_META_EVENT subevent"
elif event == bluez.EVT_INQUIRY_COMPLETE:
print "device inquiry complete"
elif event == bluez.EVT_CMD_STATUS:
status, ncmd, opcode = struct.unpack("<BBH", pkt[3:7])
if status != 0:
print "uh oh..."
printpacket(pkt[3:7])
done = True
elif event == bluez.EVT_INQUIRY_RESULT:
pkt = pkt[3:]
nrsp = struct.unpack("B", pkt[0])[0]
for i in range(nrsp):
addr = bluez.ba2str( pkt[1+6*i:1+6*i+6] )
results.append( ( addr, -1 ) )
print "[%s] (no RSSI)" % (addr,)
elif event == bluez.EVT_CMD_COMPLETE:
ncmd, opcode = struct.unpack("BB", pkt[4:6])
print "command complete: cmd: 0x%02x opcode: 0x%02x" % (ncmd, opcode)
else:
print "unknown packet, event 0x%02x " % event
print "unrecognized packet type 0x%02x" % ptype
print "event ", event
sock.setsockopt( bluez.SOL_HCI, bluez.HCI_FILTER, old_filter )
def device_inquiry_with_with_rssi(sock):
btq = BluetoothSupport()
# save current filter
old_filter = sock.getsockopt( bluez.SOL_HCI, bluez.HCI_FILTER, 14)
# perform a device inquiry on bluetooth device #0
# The inquiry should last 8 * 1.28 = 10.24 seconds
# before the inquiry is performed, bluez should flush its cache of
# previously discovered devices
flt = bluez.hci_filter_new()
bluez.hci_filter_all_events(flt)
bluez.hci_filter_set_ptype(flt, bluez.HCI_EVENT_PKT)
sock.setsockopt( bluez.SOL_HCI, bluez.HCI_FILTER, flt )
duration = 4
max_responses = 255
cmd_pkt = struct.pack("BBBBB", 0x33, 0x8b, 0x9e, duration, max_responses)
bluez.hci_send_cmd(sock, bluez.OGF_LINK_CTL, bluez.OCF_INQUIRY, cmd_pkt)
results = []
done = False
while not done:
pkt = sock.recv(255)
ptype, event, plen = struct.unpack("BBB", pkt[:3])
if event == bluez.EVT_INQUIRY_RESULT_WITH_RSSI:
pkt = pkt[3:]
nrsp = struct.unpack("B", pkt[0])[0]
for i in range(nrsp):
addr = bluez.ba2str( pkt[1+6*i:1+6*i+6] )
rssi = struct.unpack("b", pkt[1+13*nrsp+i])[0]
devclass_raw = pkt[1+8*nrsp+3*i:1+8*nrsp+3*i+3]
devclass = struct.unpack ("I", "%s\0" % devclass_raw)[0]
name = btq.get_device_name(addr)
minor, major, service = btq.get_classes(devclass)
type = btq.get_device_type(major)
services = btq.get_services_from_class(service)
srv = btq.get_services(addr)
results.append( ( addr, rssi, devclass, name, type, services, srv ) )
print("%s %d %x %s %s %s %s" % (addr, rssi, devclass, repr(name), type, '|'.join(services), repr(srv)))
elif event == bluez.EVT_INQUIRY_COMPLETE:
done = True
elif event == bluez.EVT_CMD_STATUS:
status, ncmd, opcode = struct.unpack("BBH", pkt[3:7])
if status != 0:
print("uh oh...")
printpacket(pkt[3:7])
done = True
elif event == bluez.EVT_INQUIRY_RESULT:
pkt = pkt[3:]
nrsp = struct.unpack("B", pkt[0])[0]
for i in range(nrsp):
addr = bluez.ba2str( pkt[1+6*i:1+6*i+6] )
results.append( ( addr, -1 ) )
print("[%s] (no RRSI)" % addr)
else:
print("unrecognized packet type 0x%02x" % ptype)
# restore old filter
sock.setsockopt( bluez.SOL_HCI, bluez.HCI_FILTER, old_filter )
return results
def device_inquiry_with_with_rssi(sock):
# save current filter
old_filter = sock.getsockopt( bluez.SOL_HCI, bluez.HCI_FILTER, 14)
# perform a device inquiry on bluetooth device #0
# The inquiry should last 8 * 1.28 = 10.24 seconds
# before the inquiry is performed, bluez should flush its cache of
# previously discovered devices
flt = bluez.hci_filter_new()
bluez.hci_filter_all_events(flt)
bluez.hci_filter_set_ptype(flt, bluez.HCI_EVENT_PKT)
sock.setsockopt( bluez.SOL_HCI, bluez.HCI_FILTER, flt )
duration = 4
max_responses = 255
cmd_pkt = struct.pack("BBBBB", 0x33, 0x8b, 0x9e, duration, max_responses)
bluez.hci_send_cmd(sock, bluez.OGF_LINK_CTL, bluez.OCF_INQUIRY, cmd_pkt)
results = []
done = False
if True:
pkt = sock.recv(255)
ptype, event, plen = struct.unpack("BBB", pkt[:3])
if event == bluez.EVT_INQUIRY_RESULT_WITH_RSSI:
pkt = pkt[3:]
curr_time = current_milli_time()
nrsp = struct.unpack("B", pkt[0])[0]
for i in range(nrsp):
addr = bluez.ba2str( pkt[1+6*i:1+6*i+6] )
rssi = struct.unpack("b", pkt[1+13*nrsp+i])[0]
if (int(rssi) >= -45 and addr not in purchased):
if addr in first_time:
if curr_time - first_time[addr] >= 4000 and curr_time - prev_time[addr] <= 10000:
purchased.append(addr)
print("Purchased ticket: [%s], final ping!" % addr)
with SocketIO('52.229.115.195', 80, LoggingNamespace) as socketIO:
socketIO.emit('beacon-purchased', addr);
socketIO.wait(seconds=1)
else:
if curr_time - prev_time[addr] > 10000:
print("Purchasing ticket: [%s] (reset), ping!" % addr)
first_time[addr] = curr_time
prev_time[addr] = curr_time
with SocketIO('52.229.115.195', 80, LoggingNamespace) as socketIO:
socketIO.emit('beacon-ping', addr);
socketIO.wait(seconds=1)
else:
print("Purchasing ticket: [%s], ping!" % addr)
prev_time[addr] = curr_time
with SocketIO('52.229.115.195', 80, LoggingNamespace) as socketIO:
socketIO.emit('beacon-ping', addr);
socketIO.wait(seconds=1)
else:
print("Purchasing ticket: [%s], ping!" % addr)
first_time[addr] = curr_time
prev_time[addr] = curr_time
with SocketIO('52.229.115.195', 80, LoggingNamespace) as socketIO:
socketIO.emit('beacon-ping', addr);
socketIO.wait(seconds=1)
# restore old filter
sock.setsockopt( bluez.SOL_HCI, bluez.HCI_FILTER, old_filter )
return results
def device_inquiry_with_with_rssi(sock):
global Send_Flag
#Get GPS Coordinate
report = session.next()
# save current filter
old_filter = sock.getsockopt( bluez.SOL_HCI, bluez.HCI_FILTER, 14)
# perform a device inquiry on bluetooth device #0
# The inquiry should last 8 * 1.28 = 10.24 seconds
# before the inquiry is performed, bluez should flush its cache of
# previously discovered devices
flt = bluez.hci_filter_new()
bluez.hci_filter_all_events(flt)
bluez.hci_filter_set_ptype(flt, bluez.HCI_EVENT_PKT)
sock.setsockopt( bluez.SOL_HCI, bluez.HCI_FILTER, flt )
duration = 4
max_responses = 255
cmd_pkt = struct.pack("BBBBB", 0x33, 0x8b, 0x9e, duration, max_responses)
bluez.hci_send_cmd(sock, bluez.OGF_LINK_CTL, bluez.OCF_INQUIRY, cmd_pkt)
results = []
done = False
while not done:
pkt = sock.recv(255)
ptype, event, plen = struct.unpack("BBB", pkt[:3])
if event == bluez.EVT_INQUIRY_RESULT_WITH_RSSI:
pkt = pkt[3:]
nrsp = bluetooth.get_byte(pkt[0])
for i in range(nrsp):
addr = bluez.ba2str( pkt[1+6*i:1+6*i+6] )
rssi = bluetooth.byte_to_signed_int(
bluetooth.get_byte(pkt[1+13*nrsp+i]))
results.append( ( addr, rssi ) )
#Compare device addr is connected device
if addr == dev_addr:
power = (abs(rssi)-59)/(10*2.0)
meter = pow(10, power)
print("[%s] RSSI: [%d]" % (addr, rssi))
print("Distance: [%.2f]" % meter)
if meter > 0.5:
#buzzer warning
GPIO.output(23, GPIO.HIGH)
time.sleep(1)
GPIO.output(23, GPIO.LOW)
time.sleep(1)
#change GPS coordinate
loc = wgs2bd(report.lat,report.lon)
#Send GPS Info E-mail
if os.path.exists('/home/pi/MarkPoint.html'):
Send_Flag = 0
else:
Send_Flag = 1
#Generate HTML File
generate(loc[0],loc[1])
if Send_Flag:
Send_Flag = 0
yag = yagmail.SMTP(user = '******', password = '******', host = 'smtp.qq.com')
yag.send(to = [mail_addr],subject = 'GPS Map',contents = ['GPS Coordinate','/home/pi/MarkPoint.html'])
elif event == bluez.EVT_INQUIRY_COMPLETE:
done = True
elif event == bluez.EVT_CMD_STATUS:
status, ncmd, opcode = struct.unpack("BBH", pkt[3:7])
if status != 0:
print("uh oh...")
printpacket(pkt[3:7])
done = True
elif event == bluez.EVT_INQUIRY_RESULT:
pkt = pkt[3:]
nrsp = bluetooth.get_byte(pkt[0])
for i in range(nrsp):
addr = bluez.ba2str( pkt[1+6*i:1+6*i+6] )
results.append( ( addr, -1 ) )
print("[%s] (no RRSI)" % addr)
#else:
# print("unrecognized packet type 0x%02x" % ptype)
#print("event ", event)
# restore old filter
sock.setsockopt( bluez.SOL_HCI, bluez.HCI_FILTER, old_filter )
return results
def device_inquiry_with_with_rssi(sock):
# save current filter
old_filter = sock.getsockopt(bluez.SOL_HCI, bluez.HCI_FILTER, 14)
# perform a device inquiry on bluetooth device #0
# The inquiry should last 8 * 1.28 = 10.24 seconds
# before the inquiry is performed, bluez should flush its cache of
# previously discovered devices
flt = bluez.hci_filter_new()
bluez.hci_filter_all_events(flt)
bluez.hci_filter_set_ptype(flt, bluez.HCI_EVENT_PKT)
sock.setsockopt(bluez.SOL_HCI, bluez.HCI_FILTER, flt)
duration = 1
max_responses = 255
cmd_pkt = struct.pack("BBBBB", 0x33, 0x8b, 0x9e, duration, max_responses)
while True:
bluez.hci_send_cmd(sock, bluez.OGF_LINK_CTL, bluez.OCF_INQUIRY,
cmd_pkt)
results = []
done = False
while not done:
pkt = sock.recv(255)
ptype, event, plen = struct.unpack("BBB", pkt[:3])
if event == bluez.EVT_INQUIRY_RESULT_WITH_RSSI:
pkt = pkt[3:]
nrsp = bluetooth.get_byte(pkt[0])
for i in range(nrsp):
addr = bluez.ba2str(pkt[1 + 6 * i:1 + 6 * i + 6])
rssi = bluetooth.byte_to_signed_int(
bluetooth.get_byte(pkt[1 + 13 * nrsp + i]))
# results.append( ( addr, rssi ) )
if "98:00" in str(addr) or "30:6A" in str(
addr) or 'D4' in str(addr):
print("[%s] RSSI: [%d]" % (addr, rssi))
#send request to server
#serialize json
params = {'id': id, 'address': addr, 'rssi': rssi}
a = requests.post(
'http://76339ea5.ngrok.io/read_points',
json=params,
headers={'Connection': 'close'})
requests.map([a])
elif event == bluez.EVT_INQUIRY_COMPLETE:
done = True
elif event == bluez.EVT_CMD_STATUS:
status, ncmd, opcode = struct.unpack("BBH", pkt[3:7])
if status != 0:
print("uh oh...")
printpacket(pkt[3:7])
done = True
elif event == bluez.EVT_INQUIRY_RESULT:
pkt = pkt[3:]
nrsp = bluetooth.get_byte(pkt[0])
for i in range(nrsp):
addr = bluez.ba2str(pkt[1 + 6 * i:1 + 6 * i + 6])
results.append((addr, -1))
print("[%s] (no RRSI)" % addr)
else:
print("unrecognized packet type 0x%02x" % ptype)
# restore old filter
sock.setsockopt(bluez.SOL_HCI, bluez.HCI_FILTER, old_filter)
return results
def _process_hci_event (s):
if s.sock is None: return
# voodoo magic!!!
pkt = s.sock.recv (255)
ptype, event, plen = struct.unpack ("BBB", pkt[:3])
pkt = pkt[3:]
if event == _bt.EVT_INQUIRY_RESULT:
nrsp = struct.unpack ("B", pkt[0])[0]
for i in range (nrsp):
addr = _bt.ba2str (pkt[1+6*i:1+6*i+6])
psrm = pkt[ 1+6*nrsp+i ]
pspm = pkt[ 1+7*nrsp+i ]
devclass_raw = struct.unpack ("BBB",
pkt[1+9*nrsp+3*i:1+9*nrsp+3*i+3])
devclass = (devclass_raw[2] << 16) | \
(devclass_raw[1] << 8) | \
devclass_raw[0]
clockoff = pkt[1+12*nrsp+2*i:1+12*nrsp+2*i+2]
if addr not in s.names_found and addr not in s.names_to_find:
s.names_to_find[addr] = (devclass, psrm, pspm, clockoff)
s.device_discovered (addr, devclass)
elif event == _bt.EVT_INQUIRY_RESULT_WITH_RSSI:
nrsp = struct.unpack ("B", pkt[0])[0]
for i in range (nrsp):
addr = _bt.ba2str (pkt[1+6*i:1+6*i+6])
psrm = pkt[ 1+6*nrsp+i ]
pspm = pkt[ 1+7*nrsp+i ]
# devclass_raw = pkt[1+8*nrsp+3*i:1+8*nrsp+3*i+3]
# devclass = struct.unpack ("I", "%s\0" % devclass_raw)[0]
devclass_raw = struct.unpack ("BBB",
pkt[1+8*nrsp+3*i:1+8*nrsp+3*i+3])
devclass = (devclass_raw[2] << 16) | \
(devclass_raw[1] << 8) | \
devclass_raw[0]
clockoff = pkt[1+11*nrsp+2*i:1+11*nrsp+2*i+2]
rssi = struct.unpack ("b", pkt[1+13*nrsp+i])[0]
#print "%s rssi: %i" % (addr, rssi)
if addr not in s.names_found and addr not in s.names_to_find:
s.names_to_find[addr] = (devclass, psrm, pspm, clockoff)
s.device_discovered (addr, devclass,rssi)
#s.signalstrength(addr,rssi)
elif event == _bt.EVT_INQUIRY_COMPLETE:
s.is_inquiring = False
if len (s.names_to_find) == 0:
# print "inquiry complete (evt_inquiry_complete)"
s.sock.close ()
s.inquiry_complete ()
else:
s._send_next_name_req ()
elif event == _bt.EVT_CMD_STATUS:
# XXX shold this be "<BBH"
status, ncmd, opcode = struct.unpack ("BBH", pkt[:4])
if status != 0:
s.is_inquiring = False
s.sock.close ()
# print "inquiry complete (bad status 0x%X 0x%X 0x%X)" % \
# (status, ncmd, opcode)
s.names_to_find = {}
s.inquiry_complete ()
elif event == _bt.EVT_REMOTE_NAME_REQ_COMPLETE:
status = struct.unpack ("B", pkt[0])[0]
addr = _bt.ba2str (pkt[1:7])
if status == 0:
try:
name = pkt[7:].split ('\0')[0]
except IndexError:
name = ''
if addr in s.names_to_find:
device_class = s.names_to_find[addr][0]
s.names_found[addr] = ( device_class, name)
#s.device_discovered (addr, device_class, name)
del s.names_to_find[addr]
s.name_found(addr,name)
else:
pass
else:
if addr in s.names_to_find: del s.names_to_find[addr]
# XXX should we do something when a name lookup fails?
# print "name req unsuccessful %s - %s" % (addr, status)
if len (s.names_to_find) == 0:
s.is_inquiring = False
s.sock.close ()
s.inquiry_complete ()
# print "inquiry complete (name req complete)"
else:
s._send_next_name_req ()
else:
pass
def device_inquiry_with_with_rssi(self, sock,verbose=False):
# save current filter
old_filter = sock.getsockopt( bluez.SOL_HCI, bluez.HCI_FILTER, 14)
# perform a device inquiry on bluetooth device #0
# The inquiry should last 8 * 1.28 = 10.24 seconds
# before the inquiry is performed, bluez should flush its cache of
# previously discovered devices
flt = bluez.hci_filter_new()
bluez.hci_filter_all_events(flt)
bluez.hci_filter_set_ptype(flt, bluez.HCI_EVENT_PKT)
sock.setsockopt( bluez.SOL_HCI, bluez.HCI_FILTER, flt )
cmd_pkt = struct.pack("BBBBB", 0x33, 0x8b, 0x9e, self.duration, self.max_responses)
bluez.hci_send_cmd(sock, bluez.OGF_LINK_CTL, bluez.OCF_INQUIRY, cmd_pkt)
results = []
done = False
while not done:
pkt = sock.recv(255)
ptype, event, plen = struct.unpack("BBB", pkt[:3])
if event == bluez.EVT_INQUIRY_RESULT_WITH_RSSI:
pkt = pkt[3:]
nrsp = bluetooth.get_byte(pkt[0])
for i in range(nrsp):
addr = bluez.ba2str( pkt[1+6*i:1+6*i+6] )
rssi = bluetooth.byte_to_signed_int(
bluetooth.get_byte(pkt[1+13*nrsp+i]))
devclass_raw = struct.unpack ("BBB",
pkt[1+8*nrsp+3*i:1+8*nrsp+3*i+3])
devclass = (devclass_raw[2] << 16) | \
(devclass_raw[1] << 8) | \
devclass_raw[0]
try:
name = bluetooth.lookup_name(addr)
except:
name = 'unknown'
time = datetime.datetime.now().isoformat()
results.append( [time, addr, name, rssi, devclass] )
if verbose:
print("%s,%s,%s,%s,%s" % (time,addr,name, rssi, devclass))
elif event == bluez.EVT_INQUIRY_COMPLETE:
done = True
elif event == bluez.EVT_CMD_STATUS:
status, ncmd, opcode = struct.unpack("BBH", pkt[3:7])
if status != 0:
print("uh oh...")
printpacket(pkt[3:7])
done = True
elif event == bluez.EVT_INQUIRY_RESULT:
pkt = pkt[3:]
nrsp = bluetooth.get_byte(pkt[0])
for i in range(nrsp):
addr = bluez.ba2str( pkt[1+6*i:1+6*i+6] )
results.append( ( addr, -1 ) )
if verbose:
print("[%s] (no RRSI)" % addr)
else:
print("unrecognized packet type 0x%02x" % ptype)
if verbose:
print("event ", event)
# restore old filter
sock.setsockopt( bluez.SOL_HCI, bluez.HCI_FILTER, old_filter )
return results
def _device_inquiry_with_with_rssi(self):
"""
Perform a Bluetooth inquiry with RSSI reception.
"""
# save current filter
old_filter = self.sock.getsockopt(bluez.SOL_HCI, bluez.HCI_FILTER, 14)
flt = bluez.hci_filter_new()
bluez.hci_filter_all_events(flt)
bluez.hci_filter_set_ptype(flt, bluez.HCI_EVENT_PKT)
self.sock.setsockopt(bluez.SOL_HCI, bluez.HCI_FILTER, flt)
max_responses = 0 # unlimited number of responses
cnt_responses = 0
cmd_pkt = struct.pack("BBBBB", 0x33, 0x8b, 0x9e, self.buffer_size,
max_responses)
self.logger_inquiry.new_inquiry(time.time(), self.buffer_size*1.28)
self.mgr.debug("%s: New inquiry" % self.mac)
bluez.hci_send_cmd(self.sock, bluez.OGF_LINK_CTL, bluez.OCF_INQUIRY,
cmd_pkt)
done = False
while not done:
try:
pkt = self.sock.recv(255)
except bluetooth._bluetooth.error, e:
if e[0] == 32:
self.logger.stop()
done = True
self.done = True
self.scanner.stopped_scanning(self, "adapter lost")
return
ptype, event, plen = struct.unpack("BBB", pkt[:3])
timestamp = time.time()
if event == bluez.EVT_INQUIRY_RESULT_WITH_RSSI:
pkt = pkt[3:]
nrsp = struct.unpack("B", pkt[0])[0]
cnt_responses += nrsp
if nrsp > 1:
self.mgr.log_info("%s: Discarding %i responses queued into a single result event" % (self.mac, nrsp))
continue
for i in range(nrsp):
addr = bluez.ba2str(pkt[1+6*i:1+6*i+6])
rssi = struct.unpack("b", pkt[1+13*nrsp+i])[0]
devclass_raw = pkt[1+8*nrsp+3*i:1+8*nrsp+3*i+3]
devclass = struct.unpack ("I", "%s\0" % devclass_raw)[0]
self.device_discovered(timestamp, addr, devclass, None, rssi)
elif event == 0x2f: # EVT_EXTENDED_INQUIRY_RESULT
cnt_responses += 1
pkt = pkt[3:]
addr = bluez.ba2str(pkt[1:1+6])
rssi = struct.unpack("b", pkt[14])[0]
devclass_raw = pkt[9:9+3]
devclass = struct.unpack ("I", "%s\0" % devclass_raw)[0]
eir_data = {}
eir = pkt[15:]
eir_idx = 0
while eir_idx < len(eir):
l = struct.unpack("B", eir[eir_idx])[0]
eir_idx += 1
if l > 0:
data_type = struct.unpack("B", eir[eir_idx])[0]
eir_idx += 1
data = None
if data_type in self.eir_datatypes:
dt = self.eir_datatypes[data_type]
eir_data[dt[0]] = dt[2](struct.unpack("%i%s" % ((l-1), dt[1]), eir[eir_idx:eir_idx+l-1]))
eir_idx += (l-1)
self.device_discovered(timestamp, addr, devclass, eir_data.get('tx_power_level', None), rssi)
elif event == bluez.EVT_INQUIRY_RESULT:
pkt = pkt[3:]
nrsp = struct.unpack("B", pkt[0])[0]
cnt_responses += nrsp
if nrsp > 1:
self.mgr.log_info("%s: Discarding %i responses queued into a single result event" % (self.mac, nrsp))
continue
for i in range(nrsp):
addr = bluez.ba2str(pkt[1+6*i:1+6*i+6])
devclass_raw = struct.unpack("BBB",
pkt[1+9*nrsp+3*i:1+9*nrsp+3*i+3])
devclass = (devclass_raw[2] << 16) | \
(devclass_raw[1] << 8) | \
devclass_raw[0]
self.device_discovered(timestamp, addr, devclass, None, None)
elif event == bluez.EVT_INQUIRY_COMPLETE:
done = True
elif event == bluez.EVT_CMD_STATUS:
status, ncmd, opcode = struct.unpack("BBH", pkt[3:7])
if status != 0:
self.mgr.debug('Non-zero Bluetooth status packet received')
done = True
else:
self.mgr.debug('Unrecognized Bluetooth packet type received')
def device_inquiry(sock, cycle_period, hash_addrs, log_out, device_queue):
# save current filter
old_filter = sock.getsockopt(bluez.SOL_HCI, bluez.HCI_FILTER, 14)
# perform a device inquiry on bluetooth device #0
# The inquiry should last 8 * 1.28 = 10.24 seconds
# before the inquiry is performed, bluez should flush its cache of
# previously discovered devices
filtr = bluez.hci_filter_new()
bluez.hci_filter_all_events(filtr)
bluez.hci_filter_set_ptype(filtr, bluez.HCI_EVENT_PKT)
sock.setsockopt(bluez.SOL_HCI, bluez.HCI_FILTER, filtr)
max_responses = 255
cmd_pkt = struct.pack("BBBBB", 0x33, 0x8b, 0x9e, int(cycle_period / 1.25),
max_responses)
bluez.hci_send_cmd(sock, bluez.OGF_LINK_CTL, bluez.OCF_INQUIRY, cmd_pkt)
#While still scanning
done = False
while not done:
sock.settimeout(5)
try:
pkt = sock.recv(255)
except:
break
ptype, event, plen = struct.unpack("BBB", pkt[:3])
#Enquiry result with rssi
if event == bluez.EVT_INQUIRY_RESULT_WITH_RSSI:
pkt = pkt[3:]
nrsp = bluetooth.get_byte(pkt[0])
for i in range(nrsp):
addr = bluez.ba2str(pkt[1 + 6 * i:1 + 6 * i + 6])
if (hash_addrs):
addr = hashlib.sha224(addr.replace(":", "")).hexdigest()
rssi = bluetooth.byte_to_signed_int(
bluetooth.get_byte(pkt[1 + 13 * nrsp + i]))
register_device(addr, rssi, log_out, device_queue)
#Enquiry result without rssi
elif event == bluez.EVT_INQUIRY_RESULT:
pkt = pkt[3:]
nrsp = bluetooth.get_byte(pkt[0])
for i in range(nrsp):
addr = bluez.ba2str(pkt[1 + 6 * i:1 + 6 * i + 6])
if (hash_addrs):
addr = hashlib.sha224(addr.replace(":", "")).hexdigest()
register_device(addr, None, log_out, device_queue)
#On finish
elif event == bluez.EVT_INQUIRY_COMPLETE:
done = True
#Status update?
elif event == bluez.EVT_CMD_STATUS:
status, ncmd, opcode = struct.unpack("BBH", pkt[3:7])
if status != 0:
done = True
# restore old filter
sock.setsockopt(bluez.SOL_HCI, bluez.HCI_FILTER, old_filter)
return
def device_inquiry_with_with_rssi(sock, show_name=False, show_extra_info=False, color=True, ret_table=False):
global LOADING_HANDLER
# save current filter
old_filter = sock.getsockopt( bluez.SOL_HCI, bluez.HCI_FILTER, 14)
# perform a device inquiry on bluetooth device #0
# The inquiry should last 8 * 1.28 = 10.24 seconds
# before the inquiry is performed, bluez should flush its cache of
# previously discovered devices
flt = bluez.hci_filter_new()
bluez.hci_filter_all_events(flt)
bluez.hci_filter_set_ptype(flt, bluez.HCI_EVENT_PKT)
sock.setsockopt( bluez.SOL_HCI, bluez.HCI_FILTER, flt )
duration = 1
max_responses = 255
cmd_pkt = struct.pack("BBBBB", 0x33, 0x8b, 0x9e, duration, max_responses)
# TODO Optimize code for performance
# update the global device name dictionary before sending hci cmd(which changes mode)
headers =["Name", "MAC Address", "RSSI"]
data = []
results = []
if show_extra_info or show_name:
devices = bluetooth.discover_devices(lookup_names=True, lookup_class=True)
if show_name:
update_dict = {i[0]: i[1] for i in devices}
NAME_DICT.update(update_dict)
if show_extra_info:
update_dict = {i[0]: i[2] for i in devices}
CLASS_DICT.update(update_dict)
headers.extend(["Major Dev Class", "Minor Dev Class", "Services"])
populate_info_dict()
bluez.hci_send_cmd(sock, bluez.OGF_LINK_CTL, bluez.OCF_INQUIRY, cmd_pkt)
done = False
while not done:
pkt = sock.recv(255)
ptype, event, plen = struct.unpack("BBB", pkt[:3])
if event == bluez.EVT_INQUIRY_RESULT_WITH_RSSI:
pkt = pkt[3:]
nrsp = bluetooth.get_byte(pkt[0])
for i in range(nrsp):
# get human readable addr
addr = bluez.ba2str( pkt[1+6*i:1+6*i+6] )
rssi = bluetooth.byte_to_signed_int(
bluetooth.get_byte(pkt[1+13*nrsp+i]))
# retrieve device name, or assign address as name
try:
name = NAME_DICT[addr]
except:
name = addr
results.append( ( addr, rssi, name ) )
if color:
data.append([name, addr, rssi_to_colour_str(rssi)])
else:
data.append([name, addr, rssi])
if show_extra_info:
extra_info = get_device_extra(addr)
# extend last data list with extra info
data[-1].extend(extra_info)
elif event == bluez.EVT_INQUIRY_COMPLETE:
done = True
elif event == bluez.EVT_CMD_STATUS:
status, ncmd, opcode = struct.unpack("BBH", pkt[3:7])
if status != 0:
print("uh oh...")
printpacket(pkt[3:7])
done = True
elif event == bluez.EVT_INQUIRY_RESULT:
pkt = pkt[3:]
nrsp = bluetooth.get_byte(pkt[0])
for i in range(nrsp):
addr = bluez.ba2str( pkt[1+6*i:1+6*i+6] )
results.append( ( addr, -1 , "UNK") )
print("[%s] (no RRSI)" % addr)
else:
logging.debug("unrecognized packet type 0x%02x" % ptype)
logging.debug("event %s", event)
# restore old filter
sock.setsockopt( bluez.SOL_HCI, bluez.HCI_FILTER, old_filter )
# if ordered to return a table by analyze_all, ignore other sequence
if ret_table:
if len(results) < 1:
return ( (None, headers ))
return( (data, headers) )
else:
# print all the data at once since blessings clears the screen just before
if len(results)>= 1:
# terminate concurrent loading handler
if bool(LOADING_HANDLER):
LOADING_HANDLER.terminate()
show_header("BLUETOOTH")
print(tabulate(data, headers=headers, disable_numparse=True))
else:
# LOADING_HANDLER = spin(before="Searching",
# after="\nNo devices found in nearby range")
LOADING_HANDLER.terminate()
LOADING_HANDLER = spin(before="No BT devices in nearby range")
return results
def parse_events(sock, loop_count=2):
Adstring = ""
old_filter = sock.getsockopt(bluez.SOL_HCI, bluez.HCI_FILTER, 14)
# perform a device inquiry on bluetooth device #0
# The inquiry should last 8 * 1.28 = 10.24 seconds
# before the inquiry is performed, bluez should flush its cache of
# previously discovered devices
flt = bluez.hci_filter_new()
bluez.hci_filter_all_events(flt)
bluez.hci_filter_set_ptype(flt, bluez.HCI_EVENT_PKT)
sock.setsockopt(bluez.SOL_HCI, bluez.HCI_FILTER, flt)
done = False
results = []
myFullList = []
for i in range(0, loop_count):
pkt = sock.recv(255)
ptype, event, plen = struct.unpack("BBB", pkt[:3])
#print "-------------- ptype: 0x%02x event: 0x%02x plen: 0x%02x" % (ptype, event, plen)
if event == bluez.EVT_INQUIRY_RESULT_WITH_RSSI:
pkt = pkt[3:]
nrsp = struct.unpack("B", pkt[0])[0]
for i in range(nrsp):
addr = bluez.ba2str(pkt[1 + 6 * i:1 + 6 * i + 6])
rssi = struct.unpack("b", pkt[1 + 13 * nrsp + i])[0]
results.append((addr, rssi))
#print "Inquiry: [%s] RSSI: [%d]" % (addr, rssi)
elif event == bluez.EVT_NUM_COMP_PKTS:
#print "num completed packets"
pkt = pkt[3:]
num_connection_handles = struct.unpack("B", pkt[0])[0]
pkt = pkt[1:]
#print "handles:", num_connection_handles
for i in range(0, num_connection_handles):
handle, = struct.unpack("H", pkt[0:2])
completed_packets, = struct.unpack("H", pkt[2:4])
print "\thandle: 0x%04x completed packets: 0x%04x" % (
handle, completed_packets)
pkt = pkt[4:]
elif event == bluez.EVT_DISCONN_COMPLETE:
pkt = pkt[3:]
status, handle, reason = struct.unpack("<BHB", pkt)
print "Disconnected, status: 0x%02x handle: 0x%04x reason: 0x%02x" % (
status, handle, reason)
elif event == LE_META_EVENT:
subevent, = struct.unpack("B", pkt[3])
pkt = pkt[4:]
#print "LE META EVENT subevent: 0x%02x" %(subevent,)
if subevent == EVT_LE_CONN_COMPLETE:
print "connection complete"
le_handle_connection_complete(pkt)
elif subevent == EVT_LE_ADVERTISING_REPORT:
#print "advertising report"
num_reports = struct.unpack("B", pkt[0])[0]
report_pkt_offset = 0
#print "Number of reports in the report: 0x%02x" % num_reports
for i in range(0, num_reports):
#print "report", i
report_event_type = struct.unpack(
"B", pkt[report_pkt_offset + 1])[0]
bdaddr_type = struct.unpack("B",
pkt[report_pkt_offset + 2])[0]
#print "\tadvertising report event type: 0x%02x" % report_event_type
#print "\tbdaddr type: 0x%02x" % (bdaddr_type,)
#print "\tdevice address: ", packed_bdaddr_to_string(pkt[report_pkt_offset + 3:report_pkt_offset + 9])
Adstring += packed_bdaddr_to_string(
pkt[report_pkt_offset + 3:report_pkt_offset + 9]) + ","
report_data_length, = struct.unpack(
"B", pkt[report_pkt_offset + 9])
#print "\tadvertising packet metadata length: ", report_data_length
if report_event_type == ADV_IND:
Adstring += "ADV_IND,"
elif report_event_type == ADV_DIRECT_IND:
Adstring += "ADV_DIRECT_IND,"
elif report_event_type == ADV_SCAN_IND:
Adstring += "ADV_SCAN_IND,"
elif report_event_type == ADV_NONCONN_IND:
Adstring += "ADV_NONCONN_IND,"
#Adstring = packed_bdaddr_to_string(pkt[report_pkt_offset + 3:report_pkt_offset + 9]) + ",ADV_NONCONN_IND,"
elif report_event_type == ADV_SCAN_RSP:
local_name_len = ""
name = ""
try:
local_name_len, = struct.unpack(
"B", pkt[report_pkt_offset + 11])
name = pkt[report_pkt_offset +
12:report_pkt_offset + 12 +
local_name_len]
except:
name = "n/a"
Adstring = packed_bdaddr_to_string(
pkt[report_pkt_offset + 3:report_pkt_offset + 9]
) + ",ADV_SCAN_RSP," + "name:" + name.replace(
"\n", "") + ","
else:
Adstring += "Unk,"
# each report is 2 (event type, bdaddr type) + 6 (the address)
# + 1 (data length field) + data length + 1 (rssi)
meta = ""
if report_data_length > 1:
for c in pkt[report_pkt_offset + 10:report_pkt_offset +
10 + report_data_length]:
meta += "%02x " % struct.unpack("B", c)[0]
#print "\tMmeta:", meta
Adstring += meta + ","
report_pkt_offset = report_pkt_offset + 10 + report_data_length + 1
rssi, = struct.unpack("b", pkt[report_pkt_offset - 1])
#print "\tRSSI:", rssi
Adstring += "%s" % (rssi)
elif subevent == EVT_LE_CONN_UPDATE_COMPLETE:
print "connection updated"
printpacket(pkt)
elif subevent == EVT_LE_READ_REMOTE_USED_FEATURES_COMPLETE:
print "read remote used features complete"
else:
print "unknown LE_META_EVENT subevent"
elif event == bluez.EVT_INQUIRY_COMPLETE:
print "device inquiry complete"
elif event == bluez.EVT_CMD_STATUS:
status, ncmd, opcode = struct.unpack("<BBH", pkt[3:7])
if status != 0:
print "uh oh..."
printpacket(pkt[3:7])
done = True
elif event == bluez.EVT_INQUIRY_RESULT:
pkt = pkt[3:]
nrsp = struct.unpack("B", pkt[0])[0]
for i in range(nrsp):
addr = bluez.ba2str(pkt[1 + 6 * i:1 + 6 * i + 6])
results.append((addr, -1))
print "[%s] (no RSSI)" % (addr, )
elif event == bluez.EVT_CMD_COMPLETE:
ncmd, opcode = struct.unpack("BB", pkt[4:6])
print "command complete: cmd: 0x%02x opcode: 0x%02x" % (ncmd,
opcode)
else:
print "unknown packet, event 0x%02x " % event
print "unrecognized packet type 0x%02x" % ptype
print "event ", event
#print "\tAdstring=", Adstring
done = True
print "\tAdstring=", Adstring
myFullList.append(Adstring)
Adstring = ""
sock.setsockopt(bluez.SOL_HCI, bluez.HCI_FILTER, old_filter)
return myFullList
def device_inquiry_with_with_rssi(sock):
btq = BluetoothSupport()
# save current filter
old_filter = sock.getsockopt(bluez.SOL_HCI, bluez.HCI_FILTER, 14)
# perform a device inquiry on bluetooth device #0
# The inquiry should last 8 * 1.28 = 10.24 seconds
# before the inquiry is performed, bluez should flush its cache of
# previously discovered devices
flt = bluez.hci_filter_new()
bluez.hci_filter_all_events(flt)
bluez.hci_filter_set_ptype(flt, bluez.HCI_EVENT_PKT)
sock.setsockopt(bluez.SOL_HCI, bluez.HCI_FILTER, flt)
duration = 4
max_responses = 255
cmd_pkt = struct.pack("BBBBB", 0x33, 0x8b, 0x9e, duration, max_responses)
bluez.hci_send_cmd(sock, bluez.OGF_LINK_CTL, bluez.OCF_INQUIRY, cmd_pkt)
results = []
done = False
while not done:
pkt = sock.recv(255)
ptype, event, plen = struct.unpack("BBB", pkt[:3])
if event == bluez.EVT_INQUIRY_RESULT_WITH_RSSI:
pkt = pkt[3:]
nrsp = struct.unpack("B", pkt[0])[0]
for i in range(nrsp):
addr = bluez.ba2str(pkt[1 + 6 * i:1 + 6 * i + 6])
rssi = struct.unpack("b", pkt[1 + 13 * nrsp + i])[0]
devclass_raw = pkt[1 + 8 * nrsp + 3 * i:1 + 8 * nrsp + 3 * i +
3]
devclass = struct.unpack("I", "%s\0" % devclass_raw)[0]
name = btq.get_device_name(addr)
minor, major, service = btq.get_classes(devclass)
type = btq.get_device_type(major)
services = btq.get_services_from_class(service)
srv = btq.get_services(addr)
results.append(
(addr, rssi, devclass, name, type, services, srv))
print("%s %d %x %s %s %s %s" %
(addr, rssi, devclass, repr(name), type,
'|'.join(services), repr(srv)))
elif event == bluez.EVT_INQUIRY_COMPLETE:
done = True
elif event == bluez.EVT_CMD_STATUS:
status, ncmd, opcode = struct.unpack("BBH", pkt[3:7])
if status != 0:
print("uh oh...")
printpacket(pkt[3:7])
done = True
elif event == bluez.EVT_INQUIRY_RESULT:
pkt = pkt[3:]
nrsp = struct.unpack("B", pkt[0])[0]
for i in range(nrsp):
addr = bluez.ba2str(pkt[1 + 6 * i:1 + 6 * i + 6])
results.append((addr, -1))
print("[%s] (no RRSI)" % addr)
else:
print("unrecognized packet type 0x%02x" % ptype)
# restore old filter
sock.setsockopt(bluez.SOL_HCI, bluez.HCI_FILTER, old_filter)
return results
def _process_hci_event(self):
# FIXME may not wrap _bluetooth.error properly
if self.sock is None: return
# voodoo magic!!!
pkt = self.sock.recv(258)
ptype, event, plen = struct.unpack("BBB", pkt[:3])
pkt = pkt[3:]
if event == _bt.EVT_INQUIRY_RESULT:
nrsp = get_byte(pkt[0])
for i in range(nrsp):
addr = _bt.ba2str(pkt[1 + 6 * i:1 + 6 * i + 6])
psrm = pkt[1 + 6 * nrsp + i]
pspm = pkt[1 + 7 * nrsp + i]
devclass_raw = struct.unpack(
"BBB", pkt[1 + 9 * nrsp + 3 * i:1 + 9 * nrsp + 3 * i + 3])
devclass = (devclass_raw[2] << 16) | \
(devclass_raw[1] << 8) | \
devclass_raw[0]
clockoff = pkt[1 + 12 * nrsp + 2 * i:1 + 12 * nrsp + 2 * i + 2]
self._device_discovered(addr, devclass, psrm, pspm, clockoff,
None, None)
elif event == _bt.EVT_INQUIRY_RESULT_WITH_RSSI:
nrsp = get_byte(pkt[0])
for i in range(nrsp):
addr = _bt.ba2str(pkt[1 + 6 * i:1 + 6 * i + 6])
psrm = pkt[1 + 6 * nrsp + i]
pspm = pkt[1 + 7 * nrsp + i]
# devclass_raw = pkt[1+8*nrsp+3*i:1+8*nrsp+3*i+3]
# devclass = struct.unpack ("I", "%s\0" % devclass_raw)[0]
devclass_raw = struct.unpack(
"BBB", pkt[1 + 8 * nrsp + 3 * i:1 + 8 * nrsp + 3 * i + 3])
devclass = (devclass_raw[2] << 16) | \
(devclass_raw[1] << 8) | \
devclass_raw[0]
clockoff = pkt[1 + 11 * nrsp + 2 * i:1 + 11 * nrsp + 2 * i + 2]
rssi = byte_to_signed_int(get_byte(pkt[1 + 13 * nrsp + i]))
self._device_discovered(addr, devclass, psrm, pspm, clockoff,
rssi, None)
elif _bt.HAVE_EVT_EXTENDED_INQUIRY_RESULT and event == _bt.EVT_EXTENDED_INQUIRY_RESULT:
nrsp = get_byte(pkt[0])
for i in range(nrsp):
addr = _bt.ba2str(pkt[1 + 6 * i:1 + 6 * i + 6])
psrm = pkt[1 + 6 * nrsp + i]
pspm = pkt[1 + 7 * nrsp + i]
devclass_raw = struct.unpack(
"BBB", pkt[1 + 8 * nrsp + 3 * i:1 + 8 * nrsp + 3 * i + 3])
devclass = (devclass_raw[2] << 16) | \
(devclass_raw[1] << 8) | \
devclass_raw[0]
clockoff = pkt[1 + 11 * nrsp + 2 * i:1 + 11 * nrsp + 2 * i + 2]
rssi = byte_to_signed_int(get_byte(pkt[1 + 13 * nrsp + i]))
data_len = _bt.EXTENDED_INQUIRY_INFO_SIZE - _bt.INQUIRY_INFO_WITH_RSSI_SIZE
data = pkt[1 + 14 * nrsp + i:1 + 14 * nrsp + i + data_len]
name = None
pos = 0
while (pos <= len(data)):
struct_len = get_byte(data[pos])
if struct_len == 0:
break
eir_type = get_byte(data[pos + 1])
if eir_type == 0x09: # Complete local name
name = data[pos + 2:pos + struct_len + 1]
pos += struct_len + 2
self._device_discovered(addr, devclass, psrm, pspm, clockoff,
rssi, name)
elif event == _bt.EVT_INQUIRY_COMPLETE or event == _bt.EVT_CMD_COMPLETE:
self.is_inquiring = False
if len(self.names_to_find) == 0:
# print "inquiry complete (evt_inquiry_complete)"
self.sock.close()
self._inquiry_complete()
else:
self._send_next_name_req()
elif event == _bt.EVT_CMD_STATUS:
# XXX shold this be "<BBH"
status, ncmd, opcode = struct.unpack("BBH", pkt[:4])
if status != 0:
self.is_inquiring = False
self.sock.close()
# print "inquiry complete (bad status 0x%X 0x%X 0x%X)" % \
# (status, ncmd, opcode)
self.names_to_find = {}
self._inquiry_complete()
elif event == _bt.EVT_REMOTE_NAME_REQ_COMPLETE:
status = get_byte(pkt[0])
addr = _bt.ba2str(pkt[1:7])
if status == 0:
try:
name = pkt[7:].split('\0')[0]
except IndexError:
name = ''
if addr in self.names_to_find:
device_class, rssi = self.names_to_find[addr][:2]
self.device_discovered(addr, device_class, rssi, name)
del self.names_to_find[addr]
self.names_found[addr] = (device_class, rssi, name)
else:
pass
else:
if addr in self.names_to_find: del self.names_to_find[addr]
# XXX should we do something when a name lookup fails?
# print "name req unsuccessful %s - %s" % (addr, status)
if len(self.names_to_find) == 0:
self.is_inquiring = False
self.sock.close()
self.inquiry_complete()
# print "inquiry complete (name req complete)"
else:
self._send_next_name_req()
else:
pass
def device_inquiry_with_with_rssi(sock):
# save current filter
old_filter = sock.getsockopt(bluez.SOL_HCI, bluez.HCI_FILTER, 14)
# perform a device inquiry on bluetooth device #0
# The inquiry should last 8 * 1.28 = 10.24 seconds
# before the inquiry is performed, bluez should flush its cache of
# previously discovered devices
flt = bluez.hci_filter_new()
bluez.hci_filter_all_events(flt)
bluez.hci_filter_set_ptype(flt, bluez.HCI_EVENT_PKT)
sock.setsockopt(bluez.SOL_HCI, bluez.HCI_FILTER, flt)
duration = 4
max_responses = 255
cmd_pkt = struct.pack("BBBBB", 0x33, 0x8b, 0x9e, duration, max_responses)
bluez.hci_send_cmd(sock, bluez.OGF_LINK_CTL, bluez.OCF_INQUIRY, cmd_pkt)
results = []
pkt = sock.recv(255)
ptype, event, plen = struct.unpack("BBB", pkt[:3])
done = False
xil = 0
while not done:
pkt = sock.recv(255)
ptype, event, plen = struct.unpack("BBB", pkt[:3])
if event == bluez.EVT_INQUIRY_RESULT_WITH_RSSI:
pkt = pkt[3:]
nrsp = struct.unpack("B", pkt[0])[0]
for i in range(nrsp):
addr = bluez.ba2str(pkt[1 + 6 * i:1 + 6 * i + 6])
rssi = struct.unpack("b", pkt[1 + 13 * nrsp + i])[0]
if addr == target_address:
xil = xil + 1
print " [%s] [%d]" % (addr, xil)
results.append((addr, rssi))
if xil > 0:
break
#print "[%s] RSSI: [%d]" % (addr, rssi)
elif event == bluez.EVT_INQUIRY_COMPLETE:
done = True
elif event == bluez.EVT_CMD_STATUS:
status, ncmd, opcode = struct.unpack("BBH", pkt[3:7])
if status != 0:
# print "uh oh..."
# printpacket(pkt[3:7])
done = True
#else:
# print "unrecognized packet type 0x%02x" % ptype
# restore old filter
sock.setsockopt(bluez.SOL_HCI, bluez.HCI_FILTER, old_filter)
if len(results) == 0:
return 0
else:
return 100 + results[0][1]
def parse_le_advertising_events(sock,
mac_addr=None,
packet_length=None,
handler=None,
debug=False):
"""
Parse and report LE advertisements.
This is a blocking call, an infinite loop is started and the
given handler will be called each time a new LE advertisement packet
is detected and corresponds to the given filters.
.. note:: The :func:`.start_le_advertising` function must be
called before calling this function.
:param sock: A bluetooth HCI socket (retrieved using the
``hci_open_dev`` PyBluez function).
:param mac_addr: list of filtered mac address representations
(uppercase, with ':' separators).
If not specified, the LE advertisement of any device will be reported.
Example: mac_addr=('00:2A:5F:FF:25:11', 'DA:FF:12:33:66:12')
:type mac_addr: ``list`` of ``string``
:param packet_length: Filter a specific length of LE advertisement packet.
:type packet_length: ``int``
:param handler: Handler that will be called each time a LE advertisement
packet is available (in accordance with the ``mac_addr``
and ``packet_length`` filters).
:type handler: ``callable`` taking 4 parameters:
mac (``str``), adv_type (``int``), data (``bytes``) and rssi (``int``)
:param debug: Enable debug prints.
:type debug: ``bool``
"""
if not debug and handler is None:
raise ValueError("You must either enable debug or give a handler !")
old_filter = sock.getsockopt(bluez.SOL_HCI, bluez.HCI_FILTER, 14)
flt = bluez.hci_filter_new()
bluez.hci_filter_set_ptype(flt, bluez.HCI_EVENT_PKT)
# bluez.hci_filter_all_events(flt)
bluez.hci_filter_set_event(flt, LE_META_EVENT)
sock.setsockopt(bluez.SOL_HCI, bluez.HCI_FILTER, flt)
print("socket filter set to ptype=HCI_EVENT_PKT event=LE_META_EVENT")
print("Listening ...")
try:
while True:
pkt = full_pkt = sock.recv(255)
ptype, event, plen = struct.unpack("BBB", pkt[:3])
if event != LE_META_EVENT:
# Should never occur because we filtered with this type of event
print("Not a LE_META_EVENT !")
continue
sub_event, = struct.unpack("B", pkt[3:4])
if sub_event != EVT_LE_ADVERTISING_REPORT:
if debug:
print("Not a EVT_LE_ADVERTISING_REPORT !")
continue
pkt = pkt[4:]
adv_type = struct.unpack("b", pkt[1:2])[0]
mac_addr_str = bluez.ba2str(pkt[3:9])
if packet_length and plen != packet_length:
# ignore this packet
if debug:
print(
"packet with non-matching length: mac=%s adv_type=%02x plen=%s"
% (mac_addr_str, adv_type, plen))
print(raw_packet_to_str(pkt))
continue
data = pkt[9:-1]
rssi = struct.unpack("b",
full_pkt[len(full_pkt) - 1:len(full_pkt)])[0]
if mac_addr and mac_addr_str not in mac_addr:
if debug:
print(
"packet with non-matching mac %s adv_type=%02x data=%s RSSI=%s"
% (mac_addr_str, adv_type, raw_packet_to_str(data),
rssi))
continue
if debug:
print(
"LE advertisement: mac=%s adv_type=%02x data=%s RSSI=%d" %
(mac_addr_str, adv_type, raw_packet_to_str(data), rssi))
if handler is not None:
try:
handler(mac_addr_str, adv_type, data, rssi)
except Exception as e:
print(
'Exception when calling handler with a BLE advertising event: %r'
% (e, ))
import traceback
traceback.print_exc()
except KeyboardInterrupt:
print("\nRestore previous socket filter")
sock.setsockopt(bluez.SOL_HCI, bluez.HCI_FILTER, old_filter)
raise
def device_inquiry_with_with_rssi(self, sock):
# save current filter
old_filter = sock.getsockopt( bluez.SOL_HCI, bluez.HCI_FILTER, 14)
# perform a device inquiry on bluetooth device #0
# The inquiry should last 8 * 1.28 = 10.24 seconds
# before the inquiry is performed, bluez should flush its cache of
# previously discovered devices
flt = bluez.hci_filter_new()
bluez.hci_filter_all_events(flt)
bluez.hci_filter_set_ptype(flt, bluez.HCI_EVENT_PKT)
sock.setsockopt( bluez.SOL_HCI, bluez.HCI_FILTER, flt )
duration = 1
max_responses = 255
cmd_pkt = struct.pack("BBBBB", 0x33, 0x8b, 0x9e, duration, max_responses)
bluez.hci_send_cmd(sock, bluez.OGF_LINK_CTL, bluez.OCF_INQUIRY, cmd_pkt)
results = []
done = False
while not done:
pkt = sock.recv(255)
ptype, event, plen = struct.unpack("BBB", pkt[:3])
if event == bluez.EVT_INQUIRY_RESULT_WITH_RSSI:
pkt = pkt[3:]
nrsp = bluetooth.get_byte(pkt[0])
for i in range(nrsp):
addr = bluez.ba2str( pkt[1+6*i:1+6*i+6] )
rssi = bluetooth.byte_to_signed_int(
bluetooth.get_byte(pkt[1+13*nrsp+i]))
results.append( ( addr, rssi ) )
#print("[%s] RSSI: [%d]" % (addr, rssi))
# If we found the target device print it
if addr == self.target_Address:
print("Found The Target: [%s] " % (addr))
print("Target's RSSI : [%s] " % (rssi))
# Set the RSSI if we have our target
# Set that we found it as well.
# Then break out, since we do not need
# to search any more.
self.setRSSI(rssi)
self.setFoundDevice(True)
break
elif event == bluez.EVT_INQUIRY_COMPLETE:
done = True
elif event == bluez.EVT_CMD_STATUS:
status, ncmd, opcode = struct.unpack("BBH", pkt[3:7])
if status != 0:
print("uh oh...")
printpacket(pkt[3:7])
done = True
elif event == bluez.EVT_INQUIRY_RESULT:
pkt = pkt[3:]
nrsp = bluetooth.get_byte(pkt[0])
for i in range(nrsp):
addr = bluez.ba2str( pkt[1+6*i:1+6*i+6] )
results.append( ( addr, -1 ) )
print("[%s] (no RRSI)" % addr)
else:
print("unrecognized packet type 0x%02x" % ptype)
self.printpacket(pkt)
# print("event ", event)
# restore old filter
sock.setsockopt( bluez.SOL_HCI, bluez.HCI_FILTER, old_filter )
return results
def device_inquiry_with_with_rssi(sock):
#check for rssi value
#CREDIT: code.google.com
# save current filter
old_filter = sock.getsockopt( bluez.SOL_HCI, bluez.HCI_FILTER, 14)
# perform a device inquiry on bluetooth device #0
# The inquiry should last 8 * 1.28 = 10.24 seconds
# before the inquiry is performed, bluez should flush its cache of
# previously discovered devices
flt = bluez.hci_filter_new()
bluez.hci_filter_all_events(flt)
bluez.hci_filter_set_ptype(flt, bluez.HCI_EVENT_PKT)
sock.setsockopt( bluez.SOL_HCI, bluez.HCI_FILTER, flt )
duration = 4
max_responses = 255
cmd_pkt = struct.pack("BBBBB", 0x33, 0x8b, 0x9e, duration, max_responses)
bluez.hci_send_cmd(sock, bluez.OGF_LINK_CTL, bluez.OCF_INQUIRY, cmd_pkt)
results = []
pkt = sock.recv(255)
ptype, event, plen = struct.unpack("BBB", pkt[:3])
done = False
xil = 0
while not done:
pkt = sock.recv(255)
ptype, event, plen = struct.unpack("BBB", pkt[:3])
if event == bluez.EVT_INQUIRY_RESULT_WITH_RSSI:
pkt = pkt[3:]
nrsp = struct.unpack("B", pkt[0])[0]
for i in range(nrsp):
addr = bluez.ba2str( pkt[1+6*i:1+6*i+6] )
rssi = struct.unpack("b", pkt[1+13*nrsp+i])[0]
if addr == target_address :
xil = xil + 1
print " [%s] [%d]" % (addr,xil)
results.append( ( addr, rssi ) )
if xil > 0 :
break
#print "[%s] RSSI: [%d]" % (addr, rssi)
elif event == bluez.EVT_INQUIRY_COMPLETE:
done = True
elif event == bluez.EVT_CMD_STATUS:
status, ncmd, opcode = struct.unpack("BBH", pkt[3:7])
if status != 0:
# print "uh oh..."
# printpacket(pkt[3:7])
done = True
else:
print "unrecognized packet type 0x%02x" % ptype
# restore old filter
sock.setsockopt( bluez.SOL_HCI, bluez.HCI_FILTER, old_filter )
if len(results) == 0 :
return 0
else :
return 100+results[0][1]
def get_rssis(addrs):
try:
sock = bt.hci_open_dev()
except:
print("error accessing bluetooth device...")
sys.exit(1)
try:
mode = read_inquiry_mode(sock)
except Exception as e:
print("error reading inquiry mode. ")
print("Are you sure this a bluetooth 1.2 device?")
print(e)
sys.exit(1)
if mode != 1:
try:
result = write_inquiry_mode(sock, 1)
except Exception as e:
print("error writing inquiry mode. Are you sure you're root?")
print(e)
sys.exit(1)
if result != 0:
print("error while setting inquiry mode")
# save current filter
old_filter = sock.getsockopt(bt.SOL_HCI, bt.HCI_FILTER, 14)
# perform a device inquiry on bluetooth device #0
# The inquiry should last 8 * 1.28 = 10.24 seconds
# before the inquiry is performed, bt should flush its cache of
# previously discovered devices
flt = bt.hci_filter_new()
bt.hci_filter_all_events(flt)
bt.hci_filter_set_ptype(flt, bt.HCI_EVENT_PKT)
sock.setsockopt(bt.SOL_HCI, bt.HCI_FILTER, flt)
while True:
duration = 4
max_responses = 255
cmd_pkt = struct.pack("BBBBB", 0x33, 0x8b, 0x9e, duration,
max_responses)
bt.hci_send_cmd(sock, bt.OGF_LINK_CTL, bt.OCF_INQUIRY, cmd_pkt)
results = []
done = False
while not done:
pkt = sock.recv(255)
ptype, event, plen = struct.unpack("BBB", pkt[:3])
if event == bt.EVT_INQUIRY_RESULT_WITH_RSSI:
pkt = pkt[3:]
nrsp = bluetooth.get_byte(pkt[0])
for i in range(nrsp):
addr = bt.ba2str(pkt[1 + 6 * i:1 + 6 * i + 6])
if addr in addrs:
rssi = bluetooth.byte_to_signed_int(
bluetooth.get_byte(pkt[1 + 13 * nrsp + i]))
yield (addr, rssi)
elif event == bt.EVT_INQUIRY_COMPLETE:
done = True
elif event == bt.EVT_CMD_STATUS:
status, ncmd, opcode = struct.unpack("BBH", pkt[3:7])
if status != 0:
print("uh oh...")
printpacket(pkt[3:7])
done = True
sock.setsockopt(bt.SOL_HCI, bt.HCI_FILTER, old_filter)
sys.exit(1)
# restore old filter
sock.setsockopt(bt.SOL_HCI, bt.HCI_FILTER, old_filter)
def device_inquiry_with_with_rssi(sock): #Obteccion del
# save current filter
old_filter = sock.getsockopt( bluez.SOL_HCI, bluez.HCI_FILTER, 14)
# perform a device inquiry on bluetooth device #0
# The inquiry should last 8 * 1.28 = 10.24 seconds
# before the inquiry is performed, bluez should flush its cache of
# previously discovered devices
flt = bluez.hci_filter_new()
bluez.hci_filter_all_events(flt)
bluez.hci_filter_set_ptype(flt, bluez.HCI_EVENT_PKT)
sock.setsockopt( bluez.SOL_HCI, bluez.HCI_FILTER, flt )
duration = 32 #4
max_responses = 255
cmd_pkt = struct.pack("BBBBB", 0x33, 0x8b, 0x9e, duration, max_responses)
bluez.hci_send_cmd(sock, bluez.OGF_LINK_CTL, bluez.OCF_INQUIRY, cmd_pkt)
results = []
done = False
line, = plot(datox,potenciay) #Ponemos la grafica
axis([1,50,-90,0]) #Definimos la dimension de los ejes
ylabel('Potencia (dBm)') #Nombre eje y
xlabel('Iteracion') #Nombre eje x
w=1
while not done:
pkt = sock.recv(255)
ptype, event, plen = struct.unpack("BBB", pkt[:3])
if event == bluez.EVT_INQUIRY_RESULT_WITH_RSSI:
pkt = pkt[3:]
nrsp = struct.unpack("B", pkt[0])[0]
for i in range(nrsp):
addr = bluez.ba2str( pkt[1+6*i:1+6*i+6] )
rssi = struct.unpack("b", pkt[1+13*nrsp+i])[0]
results.append( ( addr, rssi ) )
print "[%s] RSSI: [%d]" % (addr, rssi)
if addr== mac:
rssim.append(rssi)
potenciay.append(rssi) #Anadimos el nuevo valor de RSSI al vector potenciay
datox.append(w) #Anadimos el numero de iteracion al vector
w=w+1
line.set_ydata(potenciay) # Actualizamos los datos del plot
line.set_xdata(datox)
draw() #Redibujamos la grafica
elif event == bluez.EVT_INQUIRY_COMPLETE:
savefig('potencia.png') #Guardamos la imagen en un archivo
media=sum(rssim)/len(rssim)
print(media)
done = True
elif event == bluez.EVT_CMD_STATUS:
status, ncmd, opcode = struct.unpack("BBH", pkt[3:7])
if status != 0:
print "uh oh..."
printpacket(pkt[3:7])
done = True
elif event == bluez.EVT_INQUIRY_RESULT:
pkt = pkt[3:]
nrsp = struct.unpack("B", pkt[0])[0]
for i in range(nrsp):
addr = bluez.ba2str( pkt[1+6*i:1+6*i+6] )
results.append( ( addr, -1 ) )
print "[%s] (no RRSI)" % addr
else:
print "unrecognized packet type 0x%02x" % ptype
print "event ", event
# restore old filter
sock.setsockopt( bluez.SOL_HCI, bluez.HCI_FILTER, old_filter )
return results
while not self.stopthread.isSet():
ready_to_read, ready_to_write, in_error = select.select(
[self.sock], [], [], 0.1)
if len(ready_to_read) < 1:
continue
pkt = self.sock.recv(255)
ptype, event, plen = struct.unpack("BBB", pkt[:3])
if event == bluez.EVT_INQUIRY_RESULT_WITH_RSSI:
pkt = pkt[3:]
nrsp = struct.unpack("B", pkt[0])[0]
for i in range(nrsp):
addr = bluez.ba2str(pkt[1 + 6 * i:1 + 6 * i + 6])
rssi = struct.unpack("b", pkt[1 + 13 * nrsp + i])[0]
match = False
idev = None
details = []
for dev in self.devlist:
if dev[0] == addr:
match = True
idev = dev
details = idev[3]
# Update last seen detail
details[0][1] = "Last seen: " + str(
datetime.datetime.now())
break
def _device_inquiry_with_with_rssi(self):
"""
Perform a Bluetooth inquiry with RSSI reception.
"""
self.mgr.debug("%s: New inquiry" % self.mac)
self.mgr.net_send_line("STATE,%s,%0.3f,new_inquiry" % (
self.mac.replace(':',''), time.time()))
# save current filter
old_filter = self.sock.getsockopt(bluez.SOL_HCI, bluez.HCI_FILTER, 14)
flt = bluez.hci_filter_new()
bluez.hci_filter_all_events(flt)
bluez.hci_filter_set_ptype(flt, bluez.HCI_EVENT_PKT)
self.sock.setsockopt(bluez.SOL_HCI, bluez.HCI_FILTER, flt)
duration = self.buffer_size
max_responses = 255
cmd_pkt = struct.pack("BBBBB", 0x33, 0x8b, 0x9e, duration,
max_responses)
bluez.hci_send_cmd(self.sock, bluez.OGF_LINK_CTL, bluez.OCF_INQUIRY,
cmd_pkt)
done = False
while not done:
try:
pkt = self.sock.recv(255)
except bluetooth._bluetooth.error, e:
if e[0] == 32:
self.logger.stop()
done = True
self.done = True
return "adapter lost"
ptype, event, plen = struct.unpack("BBB", pkt[:3])
if event == bluez.EVT_INQUIRY_RESULT_WITH_RSSI:
pkt = pkt[3:]
nrsp = struct.unpack("B", pkt[0])[0]
for i in range(nrsp):
addr = bluez.ba2str(pkt[1+6*i:1+6*i+6])
rssi = struct.unpack("b", pkt[1+13*nrsp+i])[0]
devclass_raw = pkt[1+8*nrsp+3*i:1+8*nrsp+3*i+3]
devclass = struct.unpack ("I", "%s\0" % devclass_raw)[0]
self.device_discovered(addr, devclass, rssi)
elif event == bluez.EVT_INQUIRY_RESULT:
pkt = pkt[3:]
nrsp = struct.unpack("B", pkt[0])[0]
for i in range(nrsp):
addr = bluez.ba2str(pkt[1+6*i:1+6*i+6])
devclass_raw = struct.unpack("BBB",
pkt[1+9*nrsp+3*i:1+9*nrsp+3*i+3])
devclass = (devclass_raw[2] << 16) | \
(devclass_raw[1] << 8) | \
devclass_raw[0]
self.device_discovered(addr, devclass, None)
elif event == bluez.EVT_INQUIRY_COMPLETE:
done = True
elif event == bluez.EVT_CMD_STATUS:
status, ncmd, opcode = struct.unpack("BBH", pkt[3:7])
if status != 0:
self.mgr.debug('Non-zero Bluetooth status packet received')
done = True
else:
self.mgr.debug('Unrecognized Bluetooth packet type received')
