def __init__(self): print "Connecting to bluetooth..." target_name = "Onetouch Idol 3" #target_name = "Galaxy Mega" target_address = None nearby_devices = bluetooth.discover_devices() print nearby_devices for addr in nearby_devices: print bluetooth.lookup_name(addr) if target_name == bluetooth.lookup_name(addr): target_address = addr break print target_address uuid = "fa87c0d0-afac-11de-8a39-0800200c9a66" service_matches = bluetooth.find_service(uuid = uuid, address = target_address) if len(service_matches) == 0: print "Could not find service" sys.exit(0) port = service_matches[0]["port"] name = service_matches[0]["name"] host = service_matches[0]["host"] self.socket = bluetooth.BluetoothSocket(bluetooth.RFCOMM) self.socket.connect((host, port))
def scan(self): #all is for just scanning #not only traget_name, target_address as well #self.target_address = None #Will figure it out later found = False nb_test = self.nb_tries print 'Performing inquiry...' print ' -> requesting %s@%s' % (self.target_name, self.target_address) while found == False and nb_test > 0: if nb_test < self.nb_tries: print 'No suitable device detected, giving an other shot' nb_test -= 1 try: btdevices = bluetooth.discover_devices(flush_cache=True) except: print '[!] Couldn\'t get any bluetooth socket' sys.exit(1) print '%d nearby device(s) detected' %len(btdevices) for bdaddr in btdevices: if self.target_name == bluetooth.lookup_name(bdaddr): self.target_address = bdaddr found = True break elif self.target_address == bdaddr: self.target_name = bluetooth.lookup_name(bdaddr) found = True break if found == False and nb_test == 0: print '[!] Couldn\'t find bluetooth target called ', self.target_name print '[!] Make sure it is powered or nearby enough (about less than 8 meters distant)' sys.exit(1)
def __init__(self):
self.paths = path()
bus_name = dbus.service.BusName("custom.LBRC", bus=dbus.SessionBus())
dbus.service.Object.__init__(self, bus_name, "/custom/LBRC")
self.btserver = BTServer()
self.config = config()
self.event_listener = []
for i in (UinputDispatcher, CommandExecutor, DBUSCaller, ProfileSwitcher, MPlayer):
self._register_listener(i)
# load of config data
self.cur_profile = None
self.reload_config()
self.btserver.connect("keycode", self.handler)
self.btserver.connect(
"connect", lambda btserver, btadress, port: self.connect_cb(bluetooth.lookup_name(btadress), btadress, port)
)
self.btserver.connect(
"disconnect",
lambda btserver, btadress, port: self.disconnect_cb(bluetooth.lookup_name(btadress), btadress, port),
)
# load the default profile
self._load_default_profile()
def bluetoothInOut():
bluetoothSerial = serial.Serial("/dev/rfcomm0", baudrate=9600)
restart = 0
print(timestr)
print("Devices in the room: ")
result1 = bluetooth.lookup_name('C4:3A:BE:8E:9E:70', timeout=5)
if(result1 != None):
print("Bruna in")
say(name1)
restart=0
else:
print("Bruna out")
restart = restart + 1
result2 = bluetooth.lookup_name('00:14:01:21:11:18', timeout=10)
if(result2 != None):
print("Button in")
say(name2)
#serial.open()
restart=0
else:
print("Button out")
restart = restart + 1
print (time.time())
print (time.clock())
return restart
def getDevices():
nearby_devices = bluetooth.discover_devices(duration=getTimeoutDuration())
for bdaddr in nearby_devices:
# if target_name == bluetooth.lookup_name( bdaddr ):
# target_address = bdaddr
# break
# print bluetooth.lookup_name(bdaddr),bluetooth.socket.create_connection(bdaddr)
print bluetooth.lookup_name(bdaddr)
def isDeviceNear( devName ): # Lists the names of all the discovered devices # MAKE SURE YOUR DEVICE IS DISCOVERABLE; otherwise, you will not be # able to discover it devices = bluetooth.discover_devices() for devAddr in devices: if devName == bluetooth.lookup_name( devAddr ): print bluetooth.lookup_name( devAddr ) return True return False
def Connect():
os.system('cls')
print "\n\n Izombol keresem...\n Ellenorizd, hogy a Bluetooth eszkozok \n be vannak-e kapcsolva, es lathatoak-e!"
target_name = search_variable.get() # Az Entry widget tartalmanak string formaban való atadasa ( param )
target_address = None # a Target eszkoz MAC cime elobb NONE, majd a bdaddr ( lookup visszateresi ertek )
print " A keresett eszkoz neve: %s" % target_name
# BLUETOOTH ESZKÖZÖK KERESÉSE...
nearby_devices = bluetooth.discover_devices()
for bdaddr in nearby_devices:
if target_name == bluetooth.lookup_name( bdaddr ):
target_address = bdaddr
break
if target_address is not None:
print "\n Bluetooth eszkozt talaltam a kovetkezo MAC cimmel:", target_address # sikeres kereses "target_address" MAC cimmel
else:
print "Nem talaltam Bluetooth eszkozt a kozelben." # sikertelen kereses, ennek tobb oka lehet, pl. kikapcsolt / nem lathato modul
# CSATLAKOZÁSI KÍSÉRLET...
bd_addr = target_address
port = 1
sock.connect((bd_addr, port))
pin = search_variable2.get()
sock.send(pin) # A tartget eszozunk PIN kodja 1234
def run(self):
self.cv.acquire()
self.cv.wait()
self.cv.release()
while not self.kill_received:
if self.addresses:
devid = self.intrf.request(bandwidth=1)
print "[SCN] getting names of %d devices using hci%s..." % (len(self.addresses), devid)
try:
doneAddresses = {}
for addr in self.addresses:
#name = bluetooth.lookup_name(addr, device_id=devid)
name = bluetooth.lookup_name(addr)
self.knownDevices.setInfo(address=addr, name=name)
doneAddresses[addr] = name
self.cv.acquire()
for addr in doneAddresses:
if self.addresses.has_key(addr): self.addresses.pop(addr)
self.cv.release()
print "[SCN] inquiry ended. got the names of %d devices" % len(doneAddresses), doneAddresses
except bluetooth.btcommon.BluetoothError:
#raise bluetooth.btcommon.BluetoothError
print "[SCN] bluetooth error"
time.sleep(1)
self.intrf.release(interface=devid, bandwidth=1)
else:
#print "[SCN] there are no devices to get its names"
self.cv.acquire()
self.cv.wait()
self.cv.release()
def get_nearest_phone(self):
#finds the phone with the best rssi value. returns a tuple with phone_name,mac_address,rssi_value
nearest_phone = None
snatcher = RSSI_snatcher(self.logger) #class that gets the signal strength of a phone
devices = bluetooth.discover_devices()
for address in devices:
new_phone = snatcher.get_device_strength(address)
print("NewPhone: "+str(new_phone))
print >> self.logger, "NewPhone: "+str(new_phone)
if self.is_valid(new_phone): #executes if phone is registered
print("Phone: "+new_phone[0]+" is registered")
print >> self.logger, "Phone: "+new_phone[0]+" is registered"
if nearest_phone == None:
nearest_phone = new_phone
elif new_phone[1] >= nearest_phone[1]: #checks RSSI value is stronger and sets the strongest as nearest phone
nearest_phone = new_phone
else:
print("Phone: "+new_phone[0]+" is not registered")
print >> self.logger, "Phone: "+new_phone[0]+" is not registered"
if nearest_phone != None: #creates final return value
nearest_phone = (bluetooth.lookup_name(nearest_phone[0])
,nearest_phone[0],nearest_phone[1])
else:
nearest_phone = "No Devices Detected"
print("NearestPhone: "+str(nearest_phone))
print >> self.logger, "NearestPhone: "+str(nearest_phone)
return nearest_phone
def discover_devices(self):
'''Method to discover devices nearby'''
devices = bluetooth.discover_devices()
device_info = []
for dev in devices:
device_info.append({ 'mac' : dev, 'name' : bluetooth.lookup_name(dev) })
return device_info
def search(self, name):
"""Searches nearby devices for a given name.
Args:
name: The name of the device to search for.
Returns:
The MAC address of the device with the given
name if it was found. Otherwise returns None
"""
self.name = name
logging.debug("Searching for nearby devices.")
nearby_devices = bluetooth.discover_devices()
max_attempts = 3
while max_attempts > 0:
for addr in nearby_devices:
logging.info("Found device: %s", addr)
if bluetooth.lookup_name(addr) == name:
logging.info("Device %s is %s", addr, name)
return addr
logging.debug("Device not found. Attempts remaining: %s",
max_attempts)
max_attempts = max_attempts - 1
return None
def _listen_adaptator_lookup(self):
"""
Listen to bluetooth adaptator. This method use the
bluetooth.lookup_name(). It takes approcimatively 3 seconds
to proceed.
"""
try:
for aaddr in self._targets:
# self.log.debug("_listen_adaptator_lookup : Start \
#bluetooth.lookup_name at %s" % datetime.datetime.today())
target_name = bluetooth.lookup_name( aaddr )
# self.log.debug("_listen_adaptator_lookup : Stop \
#bluetooth.lookup_name at %s" % datetime.datetime.today())
if target_name == None:
if self._targets[aaddr]["status"] == HIGH :
self._targets[aaddr]["count"] = \
self._targets[aaddr]["count"] +1
if self._targets[aaddr]["count"] >= \
self._hysteresis:
self._trig_detect("xpl-trig", aaddr, LOW)
self.log.info("bluetooth device %s with address %s is gone" % (target_name, aaddr))
else:
self._targets[aaddr]["count"] = 0
if self._targets[aaddr]["status"] == LOW:
self._trig_detect("xpl-trig", aaddr, HIGH)
self.log.info("Match bluetooth device %s with address %s" % (target_name, aaddr))
return True
except:
self.log.error("_listen_adaptator : Error with bluetooth adaptator")
error = "traceback : %s" % \
(traceback.format_exc())
self.log.error("listen_adaptator : " + error)
return False
def searchDevices(self):
"""
Search for devices
"""
self.searchButton.set_sensitive(False)
print "Scanning for devices..."
while self.devicesList.get_active() != -1:
self.devicesList.remove_text(0)
self.textBuffer.insert(self.textBuffer.get_end_iter(), ">> Searching Bluetooth serial ports... ")
self.searchSpinner.start()
self.searchSpinner.show()
try:
self.services = bluez.find_service(uuid=bluez.SERIAL_PORT_CLASS)
except Exception as e:
print "Error, unable to search devices :", e.message[1]
return
self.textBuffer.insert(self.textBuffer.get_end_iter(), "found " + str(len(self.services)) + "\n")
for i in range (len(self.services)):
print " -> Found", self.services[i]["name"], "at", self.services[i]["host"]
self.textBuffer.insert(self.textBuffer.get_end_iter(),
" -> " + self.services[i]["name"] +
" (" + bluez.lookup_name(self.services[i]["host"], 3)+ ") at " +
self.services[i]["host"])
self.devicesList.append_text(self.services[i]["name"])
self.devicesList.set_active(0)
self.searchSpinner.stop()
self.searchSpinner.hide()
self.searchButton.set_sensitive(True)
if len(self.services) > 0:
self.connectButton.set_sensitive(True)
def tracker():
cache={}
devices={}
try:
while 1:
nearby_devices = bluetooth.discover_devices()
cache={}
for founded_addr in nearby_devices:
target_name = bluetooth.lookup_name(founded_addr)
cache[founded_addr]=target_name
if founded_addr not in devices:
devices[founded_addr]=target_name
handler.entry(target_name,founded_addr)
loginfo("ENTRY","%s: %s"%(target_name,founded_addr))
for k in devices.keys():
if k not in cache:
loginfo("QUIT","%s: %s"%(devices.get(k),k))
handler.quit(devices.get(k),k)
del devices[k]
handler.update(devices)
loginfo("UPDATE","devices: %s"%devices)
if options.repeat==False:
loginfo("INFO","quit")
break
time.sleep(options.sleeptime);
except BluetoothError,e:
print >>sys.stderr, "error: %s"%e
def main():
if (len(sys.argv) > 1):
duration = sys.argv[1]
else:
duration = 10
print("Scanning Area")
MACs = bluetooth.discover_devices(duration, True, False)
print("Scan Complete")
print("MAC Address found: ")
print(MACs)
deviceNamesArray = []
x = 0
for MACAddress in MACs:
devicename = bluetooth.lookup_name(MACAddress, 20)
if (devicename == None): #device name cant be found
print ("Cant find device name for:" + MACAddress)
devicename = "NameNotFound"
deviceNamesArray.append(devicename)
print("Devices found: ")
print(deviceNamesArray)
addMACAddress(deviceNamesArray, MACs)
def lg_da():
result = bluetooth.lookup_name('00:18:6B:B3:5E:04', timeout=3)
time.sleep(3)
if (result != None):
return 1
else:
return 0
def plan_da():
result = bluetooth.lookup_name('48:C1:AC:98:9E:62', timeout=3)
time.sleep(3)
if (result != None):
return 1
else:
return 0
def service_connect( deviceName, serviceName ):
target = find_device_address_by_name(deviceName)
services = bluetooth.find_service(address=target)
for svc in services:
print 'Device Name: %s' % bluetooth.lookup_name(svc['host'])
print 'Service Name: %s' % svc['name']
print ' Host: %s' % svc['host']
print ' Description: %s' % svc['description']
print ' Provided By: %s' % svc['provider']
print ' Protocol: %s' % svc['protocol']
print ' channel/PSM: %s' % svc['port']
print ' svc classes: %s' % svc['service-classes']
print ' profiles: %s' % svc['profiles']
print ' service id: %s' % svc['service-id']
print ''
if svc['host'] == target and svc['name'] == serviceName:
print 'Connecting to OBEX File Transfer thingy...'
protocols = {
'RFCOMM': bluetooth.RFCOMM,
'L2CAP': bluetooth.L2CAP
}
sock=bluetooth.BluetoothSocket( protocols[svc['protocol']] )
sock.connect((svc['host'], svc['port']))
return sock
raise ValueError('Could not find "%s" service on %s' % (
serviceName,
deviceName
))
def _listen_adaptator_discovery(self):
"""
Listen to bluetooth adaptator. This method use the
bluetooth.discover_devices(). It takes approcimatively 10 seconds
to proceed. Phones must be "visible" in bluetooth.
"""
try:
# self.log.debug("_listen_adaptator_discovery : Start \
#bluetooth.discover_devices at %s" % datetime.datetime.today())
nearby_devices = bluetooth.discover_devices()
# self.log.debug("_listen_adaptator_discovery : Stop \
#bluetooth.discover_devices at %s" % datetime.datetime.today())
for aaddr in self._targets:
if self._targets[aaddr]["status"] == HIGH :
if aaddr not in nearby_devices:
self._targets[aaddr]["count"] = \
self._targets[aaddr]["count"] +1
if self._targets[aaddr]["count"] >= self._hysteresis:
self._trig_detect("xpl-trig", aaddr, LOW)
for bdaddr in nearby_devices:
target_name = bluetooth.lookup_name( bdaddr )
if bdaddr in self._targets:
self._targets[bdaddr]["count"] = 0
if self._targets[bdaddr]["status"] == LOW:
self._trig_detect("xpl-trig", bdaddr, HIGH)
self.log.info("Match bluetooth device %s with address %s" % (target_name, bdaddr))
return True
except:
self.log.error("_listen_adaptator : Error with bluetooth adaptator")
error = "traceback : %s" % \
(traceback.format_exc())
self.log.error("listen_adaptator : " + error)
return False
def listen_discovery():
"""
Listen to bluetooth adaptator. This method use the
bluetooth.discover_devices(). It takes approcimatively 10 seconds
to proceed. Phones must be "visible" in bluetooth.
"""
try:
nearby_devices = bluetooth.discover_devices()
syslog.syslog(syslog.LOG_DEBUG, 'listen_discovery devices discovered %s' % nearby_devices)
for phon in phones.keys():
if phones[phon]["status"] == 1 :
if phone not in nearby_devices:
phones[phon]["count"] = phones[phon]["count"] + 1
if phones[phon]["count"] >= hysteresis:
client.emitEvent(ex_bluescan%phon,"event.device.statechanged", "0", "")
phones[phon]["status"] = 0
syslog.syslog(syslog.LOG_DEBUG, "%s has gone"%phon)
for phon in nearby_devices:
if phon in phones.keys():
if 'name' not in phones[phon] :
phones[phon]['name'] = bluetooth.lookup_name(phon)
phones[phon]["count"] = 0
if phones[phon]["status"] == 0:
phones[phon]["status"] = 1
client.emitEvent(ex_bluescan%phon,"event.device.statechanged", "255", "")
syslog.syslog(syslog.LOG_DEBUG, "%s is here"%phon)
return True
except :
error = traceback.format_exc()
syslog.syslog(syslog.LOG_ERR, 'Error when discovering devices in listen_discovery')
log_exception(error)
return False
def getNewDevice():
nearby_devices = bluetooth.discover_devices(duration=getTimeoutDuration())
print nearby_devices
for btaddr in nearby_devices:
if bluetooth.lookup_name(btaddr)==cfg.newDeviceName():
return btaddr
return None
# for bdaddr in nearby_devices:
# print bluetooth.lookup_name(bdaddr)
# print nearby_devices
#
# while(1):
# server_sock = bluetooth.BluetoothSocket()
# server_sock.bind(("",3))
# server_sock.listen(1)
# client_socket, address = server_sock.accept()
#
# time.sleep(1)
# client_sock = bluetooth.BluetoothSocket()
# client_sock.connect((nearby_devices[0],3))
# client_sock.bind()
def getBTTransport(self):
if sys.platform == 'symbian_s60':
import btsocket
sock=btsocket.socket(btsocket.AF_BT,btsocket.SOCK_STREAM)
addr,services=btsocket.bt_discover()
if len(services)>0:
port = services[u'opencoin']
else:
port=services[services.keys()[0]]
address=(addr,port)
sock.connect(address)
else:
import bluetooth as bt
#evil hack
appuifw.note(u'Searching for devices','info')
results = [r for r in bt.find_service() if r['name']==None]
targets = []
for result in results:
targets.append(u'%s' % (bt.lookup_name(result['host'])))
selected = appuifw.popup_menu(targets,u'Connect to...?')
host = results[selected]['host']
#port = results[selected]['port']
port = 3
print 'host: %s, port: %s' % (host,port)
sock=bt.BluetoothSocket( bt.RFCOMM )
sock.connect((host, port))
return transports.BTTransport(sock)
def find_lights():
""" Finds nearby lights and adds them to the dictionary """
print("Discovering devices...")
nearby_devices = bt.discover_devices()
for address in nearby_devices:
name = bt.lookup_name(address)
# Ignore non-lights
if name.startswith("Light"):
# Get the light number from the name
num = int(name[-2:])
# Check to see if we already found the light
if not num in lights:
# Create a light object
print("Found light", num)
lights[num] = Light(address, num)
elif not lights[num].is_connected:
# We found the light, but it wasn't able to connect. Try again
print("Attempting to reconnect light", num)
lights[num].connect_light()
# Figure out how many lights are connected
count = 0
for light in lights:
if lights[light].is_connected:
count += 1
if count == 0:
print("No lights are connected!")
else:
# Save the lights
pickle.dump(lights, open("saved_lights.p", "wb"))
return count
def find_device(self):
while self.run and not self.connected:
if bluetooth_available:
if self.last_mac:
for i in range(100):
print "lost connection? trying to reconnect to last mac, try:" , i
try:
self.btconnect(self.last_mac)
break
except Exception, e:
print e
print traceback.format_exc()
time.sleep(0.3)
devices_macs = bluetooth.discover_devices()
print "found: " , devices_macs
for device_mac in devices_macs:
if device_mac in config.macs:
self.btconnect(device_mac)
return
for device_mac in devices_macs:
if bluetooth.lookup_name(device_mac) in config.names:
self.btconnect(device_mac)
#time.sleep(2)
return
try:
self.sock = None
self.ser = serial.Serial(self.list_serial_ports()[0], 115200, timeout=1)
print "connected to " , self.ser
self.flush_input()
self.connected = True
return
except Exception as e:
print("could not connect, retrying in 3s\n", e )
time.sleep(3)
def scan(self, args = None):
"""
Scan for bluetooth devices
"""
self._log.debug("scan : Start ...")
data = []
fmtret = "%-15s | %-15s"
nb = 0
try:
nearby_devices = bluetooth.discover_devices()
data.append(fmtret % ("Address", "Name"))
data.append(fmtret % ("---------------", "---------------"))
for bdaddr in nearby_devices:
nb = nb+1
target_name = bluetooth.lookup_name(bdaddr)
data.append(fmtret % (bdaddr, target_name))
data.append(fmtret % ("---------------", "---------------"))
data.append("Found %s bluetooth devices." % nb)
except:
data.append("Error with bluetooth adaptator. Look at logs.")
self._log.error("Error with bluetooth adaptator")
error = "traceback : %s" % \
(traceback.format_exc())
self._log.error("Exception : " + error)
self._log.debug("telldusHelper.list : Done")
return data
def searchControll(self):
try:
nearby_devices = bluetooth.discover_devices()
for bdaddr in nearby_devices:
if self.target_name == bluetooth.lookup_name( bdaddr ):
self.target_address = bdaddr
break
if self.target_address is not None:
print "Dispositivo encontrado com o endereço ", self.target_address
#recebe do dispostivo
#envia pra o controle
sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM )
sock.connect((self.target_address, self.port))
print("conexao aceita")
sock.send(self.comannd)
sock.close()
else:
print "Nao há dispositivos na proximidade"
except Exception as e:
print e
def __init__(self):
target = "BT-GPS"
nearby_devices = bluetooth.discover_devices()
for dev in nearby_devices:
if bluetooth.lookup_name(dev) == target:
# Get GPS stuff
pass
def getPresence(self):
"""Detects whether the device is near by or not"""
result = bluetooth.lookup_name(self.address, timeout=25)
if(result != None):
return "ON"
else:
return "OFF"
def listen_lookup():
"""
Listen to bluetooth adaptator. This method use the
bluetooth.lookup_name(). It takes approcimatively 3 seconds
to proceed.
"""
try:
for phon in phones:
target_name = bluetooth.lookup_name( phon )
if target_name == None:
if phones[phon]["status"] == 1 :
phones[phon]["count"] = phones[phon]["count"] + 1
if phones[phon]["count"] >= hysteresis:
phones[phon]["status"] = 0
client.emitEvent(ex_bluescan%phon,"event.device.statechanged", "0", "")
syslog.syslog(syslog.LOG_DEBUG, "%s has gone"%phon)
else:
phones[phon]["count"] = 0
if phones[phon]["status"] == 0:
phones[phon]["status"] = 1
client.emitEvent(ex_bluescan%phon,"event.device.statechanged", "255", "")
syslog.syslog(syslog.LOG_DEBUG, "%s is here"%phon)
return True
except :
error = traceback.format_exc()
syslog.syslog(syslog.LOG_ERR, 'Error when discovering devices in listen_lookup')
log_exception(error)
def get_presence(self):
"""Detects whether the device is near by or not using lookup_name"""
result = bluetooth.lookup_name(self.address, timeout=25)
if result is not None:
return "ON"
else:
return "OFF"
def lookup_name(mac: str) -> str | None:
"""Lookup a Bluetooth device name."""
_LOGGER.debug("Scanning %s", mac)
return bluetooth.lookup_name(mac, timeout=5) # type: ignore[no-any-return]
try:
NearbyDevices = bluetooth.discover_devices()
except KeyboardInterrupt:
exit()
except:
print(
"unable to discover device, check your bluetooth settings")
print(NearbyDevices)
# scan through all the available BT devices and if the server MAC is found
# then connect to the server
for Address in NearbyDevices:
# this step is just to get the name of the BT device, it is not used
# anywhere just for information purpose
try:
name = bluetooth.lookup_name(Address)
except:
print("unable to fetch name")
print(name, Address, TargetMACAddress)
# connect to the server if MAC address is found
if Address == TargetMACAddress:
# search for the service broadcasted by server
print("Services available with chip server",
TargetMACAddress)
services = bluetooth.find_service(address=TargetMACAddress)
for ser in services:
if ser['name'] == "Chip device":
print ser # this display only the service with serial_port
# the service addtion we did
# check the description portion for the device
# address
import bluetooth
import os
import time
devices = bluetooth.discover_devices()
#Searching for HC-05 in the detected devices
hc05_found = False
for device in devices:
device_name = bluetooth.lookup_name(device)
if device_name == "HC-05\n":
hc05_found = True
break
if not hc05_found:
print "Required device not found.\nPlease check your connections and try again."
exit()
else:
print "Device found.\nRefreshing..."
port = 1
sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
sock.connect((device, port))
sock.send('r')
print "Refreshing complete."
sock.close()
def lookUpNearbyBluetoothDevices(): nearby_devices = bluetooth.discover_devices() for bdaddr in nearby_devices: print str(bluetooth.lookup_name( bdaddr )) + " [" + str(bdaddr) + "]"
import sys
import bluetooth
device_name = None
device_address = None
# Device name may be supplied by user
if len(sys.argv) > 1:
device_name = sys.argv[1]
# Discover
discovered_devices = bluetooth.discover_devices()
# List of devices found
print "Devices Found:"
for a_device_address in discovered_devices:
print ">",bluetooth.lookup_name( a_device_address ), a_device_address
if device_name == bluetooth.lookup_name( a_device_address ):
device_address = a_device_address
break
# Report status if device requested
if device_name is not None:
if device_address is not None:
print "Found bluetooth device: ", device_name, " with address: ", device_address
else:
print "Could not find bluetooth device: ", device_name
# TODO: Add exit code
self.current_value = None
self.running = True #setting the thread running to true
def run(self):
global gpsd
while gpsp.running:
gpsd.next(
) #this will continue to loop and grab EACH set of gpsd info to clear the buffer
if __name__ == '__main__':
gpsp = GpsPoller() # create the thread
try:
gpsp.start() # start it up
while True:
tom = bluetooth.lookup_name(BEACON.rstrip(), timeout=110)
if ((tom != None) or (GPIO.input(38))):
while (GPIO.input(38)):
GPIO.output(RELAY1, 0)
GPIO.output(RELAY2, 0)
GPIO.output(RELAY3, 0)
GPIO.output(RELAY4, 0)
GPIO.output(RELAY5, 0)
GPIO.output(RELAY6, 0)
GPIO.output(RELAY7, 0)
GPIO.output(RELAY8, 0)
bl.set_power(True)
time.sleep(10)
check = "Key Engaged, " + time.strftime(
"%d %b %Y %H:%M:%S", time.localtime()) + ", " + str(
gpsd.fix.latitude) + ", " + str(
import bluetooth as bt
import time
#######################################################
# Scan
#######################################################
#print(bt.discover_devices())
target_name = "ROBOTIS BT-210" # target device name
target_address = "B8:63:BC:00:48:C8"
port = 1 # RFCOMM port
nearby_devices = bt.discover_devices()
# scanning for target device
for bdaddr in nearby_devices:
print(bt.lookup_name(bdaddr))
if target_name == bt.lookup_name(bdaddr):
target_address = bdaddr
break
if target_address is not None:
print('device found. target address %s' % target_address)
else:
print('could not find target bluetooth device nearby')
try:
sock = bt.BluetoothSocket(bt.RFCOMM)
sock.connect((target_address, port))
while True:
try:
import sys
import bluetooth
nearby_devices = bluetooth.discover_devices()
num = 0
print "select devices by entering a number"
for i in nearby_devices:
num += 1
print num, ": ", bluetooth.lookup_name(i)
select = input("> ") - 1
##Bluetooth search is over
print "Bluetooth selected: ", bluetooth.lookup_name(nearby_devices[select])
bd_addr = nearby_devices[select]
print(bd_addr)
##connecting to the blue tooth
try:
sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
sock.connect((bd_addr, 1))
print("Initial Connection")
except BluetoothError as bt:
print("Cannot connect to host" + str(bt))
exit(0)
##Testing out the sending
try:
sock.send("test")
print("")
# nearby_devices = bluetooth.discover_devices()
# num = 0
# print ("Select your device by entering its coresponding number...")
# for i in nearby_devices:
# num+=1
# print (num , ": " , bluetooth.lookup_name( i ))
#selection = int(input("> ")) - 1
#print ("You have selected "+bluetooth.lookup_name(nearby_devices[selection]))
#addr = nearby_devices[selection]
addr = "FC:A8:9B:00:0F:18"
print(addr)
name = bluetooth.lookup_name(addr)
passkey = "1234" # passkey of the device you want to connect
try:
port = 1
socket = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
socket.connect((addr, port))
except bluetooth.btcommon.BluetoothError as err:
# Error handler
pass
def disconnect():
#Close socket connection to device
socket.close()
file.write("""<META HTTP-EQUIV="refresh" CONTENT="15">""")
file.write("\n")
file.write("</head>" + "\n")
file.write("<body>" + "\n")
file.write("<p>" + line1 + "</p>" + "\n")
file.write("<p>" + line2 + "</p>" + "\n")
file.write("<p>" + line3 + "</p>" + "\n")
file.write("</body>" + "\n" + "</html>")
file.close()
return
print "Helloooooooo."
n1 = "name1"
n2 = "name2"
n3 = "name3"
member1 = "00:61:71:BE:24:E5"
tejas = "B4:8B:19:B7:10:21"
nirmala = "C0:EE:FB:42:5A:82"
while True:
print "Checking " + time.strftime("%a, %d %b %Y %H:%M:%S", time.gmtime())
result = bluetooth.lookup_name(member1, timeout=5)
inoutprint(n1, result, 1)
result = bluetooth.lookup_name(member2, timeout=5)
inoutprint(n2, result, 2)
result = bluetooth.lookup_name(member3, timeout=5)
inoutprint(n3, result, 3)
filewrite()
time.sleep(5)
#!/usr/bin/python
import bluetooth
import time
from lcd_display import lcd
d = lcd()
d.clear()
d.display_string("Who's Home?", 1)
sleep_time = 600
while True:
string = ''
result = bluetooth.lookup_name('1C:66:AA:CF:DD:35', timeout=5)
if (result != None):
string = string + ' Dad'
d.display_string(string, 2)
result = bluetooth.lookup_name('94:3A:F0:63:2D:99', timeout=5)
if (result != None):
string = string + ' Mum'
d.display_string(string, 2)
result = bluetooth.lookup_name('34:BB:1F:39:DE:12', timeout=5)
if (result != None):
string = string + ' Sophie'
d.display_string(string, 2)
f = open('whoshome.log', 'a')
"Please specify the number of the device you want to track: ")
# extract out the useful info on the desired device for use later
addr, name = nearby_devices[device_num][0], nearby_devices[device_num][1]
print("The script will now scan for the device %s." % (addr))
print(
"Feel free to move near and far away from the BeagleBone to see the state change on the LED.\nUse Ctrl+c to exit..."
)
GPIO.setup(led_pin, GPIO.OUT)
while True:
# Try to gather information from the desired device.
# We're using two different metrics (readable name and data services)
# to reduce false negatives.
state = bluetooth.lookup_name(addr, timeout=20)
services = bluetooth.find_service(address=addr)
# Flip the LED pin on or off depending on whether the device is nearby
if state == None and services == []:
print("No device detected in range...")
GPIO.output(led_pin, GPIO.LOW)
else:
print("Device detected!")
GPIO.output(led_pin, GPIO.HIGH)
# Arbitrary wait time
time.sleep(1)
#!/usr/bin/python
import bluetooth
import time
def searchForThinkGearDevices(self):
#self.pushButtonBluetoothSearch.setText('Searching')
mindset_devices = []
if (sys.platform == 'win32'):
for portname in self.enumerateSerialPorts():
if portname not in mindset_devices:
#portname = self.fullPortName(portname)
mindset_devices.append(portname)
else:
# Bluetooth module doesn't compile properly under Windows
bluetooth_devices = []
#bluetooth_devices = bluetooth.discover_devices( \
#duration=5, \
#flush_cache=True, \
#lookup_names=True)
command = '%s con' % PATH_TO_HCITOOL
output = os.popen(command, 'r')
for line in output.readlines():
try:
address = line.split(' ')[2]
except:
pass
else:
bluetooth_devices.append(address)
for address in bluetooth_devices:
device_name = bluetooth.lookup_name(address)
if ((device_name == 'MindSet') and \
(address not in mindset_devices)):
mindset_devices.append(address)
if self.DEBUG:
print "Bluetooth MindSet devices found:",
print mindset_devices
self.comboBoxDeviceSelect.clear()
self.comboBoxDeviceSelect.addItem('MindSet Emulator')
if os.path.exists('/dev/ttyUSB0'):
self.comboBoxDeviceSelect.addItem('/dev/ttyUSB0')
if os.path.exists('/dev/ttyUSB1'):
self.comboBoxDeviceSelect.addItem('/dev/ttyUSB1')
if os.path.exists('/dev/ttyUSB2'):
self.comboBoxDeviceSelect.addItem('/dev/ttyUSB2')
if os.path.exists('/dev/ttyUSB3'):
self.comboBoxDeviceSelect.addItem('/dev/ttyUSB3')
if os.path.exists('/dev/ttyUSB4'):
self.comboBoxDeviceSelect.addItem('/dev/ttyUSB4')
for mindset_device in mindset_devices:
self.comboBoxDeviceSelect.addItem(mindset_device)
import bluetooth
import subprocess
if bluetooth.lookup_name("40:4E:36:4A:04:C4") != None:
subprocess.call(["/home/student/server/bluetooth/beep"])
import bluetooth
target_name = "FYP_GLOVE"
target_address = None
rfcomm_port = 0
dataLine = [] # make byte array
print("Searching")
nearby_devices = bluetooth.discover_devices()
for bdaddr in nearby_devices:
if target_name == bluetooth.lookup_name(bdaddr):
target_address = bdaddr
break
if target_address is not None:
print("found target bluetooth device with address ", target_address)
server_sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
server_sock.connect((bdaddr, 1))
print("Accepted connection from ", bdaddr)
print("Hello World")
server_sock.send("Hello World")
# proves loop to take 6 bytes(3 hex numbers) to play midi note
while 1:
dataLine.clear
print("------------------------")
for num in range(30):
import bluetooth
nearby_devices = bluetooth.discover_devices()
for bdaddr in nearby_devices:
print(bluetooth.lookup_name(bdaddr))
import bluetooth
import sys, pygame
from pygame.locals import *
pygame.init()
print "Searching for device..."
print ""
device = -1
while 1:
print "doing pass"
nearby_devices = bluetooth.discover_devices()
for i in nearby_devices:
if bluetooth.lookup_name(i) == "NORMAL":
device = i
print "found!"
if device != -1:
break
print bluetooth.lookup_name(device), " has been located"
sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
sock.connect((device, 1))
pygame.init()
size = width, height = 320, 240
pygame.display.set_mode(size)
keys = pygame.key.get_pressed()
state = ["s", "s"]
while 1:
for event in pygame.event.get():
- sudo apt-get install bluez
- sudo apt-get install python-bluez
'''
from wia import Wia
import bluetooth
import time
wia = Wia()
wia.access_token = "" # Wia secret key.
print ("Proximity Check")
while True:
print ("Checking " + time.strftime("%a, %d %b %Y %H:%M:%S", time.gmtime()))
nearby_devices = bluetooth.discover_devices()
result = bluetooth.lookup_name("AA:BB:CC:DD:EE:FF", timeout=3) # Enter your device MAC address found in mobile settings. [Settings -> about (if on iphone)].
if (result != None):
print ("Parent: Present")
presence = 'Present'
else:
print ("Parent: Absent")
presence = 'Absent'
wia.Event.publish(name="Parent", data=presence)
time.sleep(20)
l_step = 1 #------
#-------------------------------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------------------------------
#Look for all Bluetooth devices
#the computer knows about.
print("Searching for devices...")
print("")
#Create an array with all the MAC
#addresses of the detected devices
nearby_devices = bluetooth.discover_devices()
#Run through all the devices found and list their name
num = 0
print("Select your device by entering its coresponding number...")
for i in nearby_devices:
num += 1
print(num, ": ", bluetooth.lookup_name(i))
#Allow the user to select their Arduino
#bluetooth module. They must have paired
#it before hand.
selection = int(input("> ")) - 1
print("You have selected", bluetooth.lookup_name(nearby_devices[selection]))
bd_addr = nearby_devices[selection]
l = [bd_addr]
print(l)
port = 1
#________________________________________________________________________________________________________________
sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
sock.connect((bd_addr, 1))
sock.send("F")
# ensure Bluetooth address has been provided as an argument
if len(sys.argv) < 2:
print("Usage: btpl.py <bluetooth address>")
sys.exit(1)
# get Bluetooth address of target device
BTAddress = sys.argv[1]
# tell user the program is running
print("Identifying device...")
try:
# display device name, with the first part bold & green
print("\033[1;32m[OK]\033[0m Device found:",
bluetooth.lookup_name(BTAddress, timeout=5))
# run forever
while True:
# reset previous status, so screen status is only changed when status changes
prev_status = status
# retrieve the current RSSI of the bluetooth device
rssi = getRSSI()
# if device is close enough:
if rssi > (0 - rangeLimit):
status = "near"
BTInRange = True
screenLocked = False
awayCounter = 0
if (prev_status == "gone") and not (firstRun):
os.system(enteredRange)
import bluetooth
target_name = "Galaxy J7"
target_address = None
# 한번에 찾아지지 않을 수 있음
nearby_devices = bluetooth.discover_devices()
for bdaddr in nearby_devices:
print("current ", bdaddr, bluetooth.lookup_name(bdaddr))
if target_name == bluetooth.lookup_name(bdaddr):
target_address = bdaddr
break
if target_address is not None:
print("Target Address:", target_address)
else:
print("Not found")
def leerComando():
print 'Sintaxis: <C>'
print 'Ejemplos: \nR012\nG055\nB255'
c = raw_input('Ingrese comando: ')
return c
#Buscaremos conectarnos con mi dispositivo Bluetooth
miBT = 'IvanBT'
print 'Buscando dispositivos Bluetooth...'
dispositivosCercanos = bluetooth.discover_devices()
for btAddr in dispositivosCercanos:
if miBT == bluetooth.lookup_name(btAddr):
miAddr = btAddr
break
if miAddr is not None:
print 'Conectando a ' + miBT + '...'
bt = conectarBT(miAddr)
print 'Conectado!\n\n'
try:
while True:
bt.send(leerComando())
except KeyboardInterrupt:
bt.close()
print 'Adios!'
else:
print 'Dispositivo no encontrado :('
i = 0 # Just an incrementer for labeling the list entries
# Print out a list of all the discovered Bluetooth Devices
for addr, name in nearby_devices:
print(("%s. %s - %s" % (i, addr, name)))
i =+ 1
device_num = eval(input("Please specify the number of the device you want to track: "))
# extract out the useful info on the desired device for use later
addr, name = nearby_devices[device_num][0], nearby_devices[device_num][1]
print(("The script will now scan for the device %s." % (addr)))
print("Feel free to move near and far away from the BeagleBone to see the state change on the LED.\nUse Ctrl+c to exit...")
GPIO.setup(led_pin, GPIO.OUT)
while True:
# Try to gather information from the desired device.
# We're using two different metrics (readable name and data services)
# to reduce false negatives.
state = bluetooth.lookup_name(addr, timeout=20)
services = bluetooth.find_service(address=addr)
# Flip the LED pin on or off depending on whether the device is nearby
if state == None and services == []:
print("No device detected in range...")
GPIO.output(led_pin, GPIO.LOW)
else:
print("Device detected!")
GPIO.output(led_pin, GPIO.HIGH)
# Arbitrary wait time
time.sleep(1)
if len(sys.argv) < 2:
print("usage bluefence.py <btaddr>")
sys.exit(1)
btAddr = sys.argv[1]
btInRange = True
screenLocked = False
awayCounter = 0
print("Identifying device...")
try:
# initial check, see if mentioned BT device active. If it's not, clean exit
btName = bluetooth.lookup_name(btAddr, timeout=5)
if btName:
if VERBOSE:
print('OK: Found your device', btName)
while True:
who = bluetooth.lookup_name(btAddr, timeout=2)
if who:
status = 'near'
btInRange = True
awayCounter = 0
os.system(IF_BT_BACK)
import home
import sys
from subprocess import call
import time
import bluetooth
call(['sudo', 'hciconfig', 'hci0', 'down'])
call(['sudo', 'hciconfig', 'hci0', 'up'])
home = home.Home()
while True:
result = bluetooth.lookup_name("8C:1A:BF:92:EC:85", timeout=10)
home.tick(result != None)
if (result != None):
time.sleep(5)
name = None
now = int(time.time())
devices.append({ 'uuid' : uuid, 'name' : name, 'in_last_time' : now, 'out_last_time' : now, 'in_age' : 999, 'out_age' : 0})
while True:
for device in devices:
uuid = device['uuid']
name = device['name']
print('uuid = ' + uuid + " Name = " + name)
if (device['in_age'] > 5):
result = bluetooth.lookup_name(uuid, timeout=5)
if (result != None):
device['in'] = 1
device['in_last_time'] = int(time.time())
print "IN"
else:
device['in'] = 0
device['out_last_time'] = int(time.time())
print "OUT"
now = int(time.time())
device['out_age'] = now - device['in_last_time']
def lookUpNearbyBluetoothDevices():
print("Scanning...")
nearby_devices = bluetooth.discover_devices()
for bdaddr in nearby_devices:
print( str(bluetooth.lookup_name( bdaddr )) + " [" + str(bdaddr) + "]")
IF_BT_BACK = 'xrandr --output eDP1 --brightness 1' # The command to run when the device is back in range
MAX_MISSED = 3
VERBOSE = True
if len(sys.argv) < 2:
print("usage bluefence.py <btaddr>")
sys.exit(1)
btaddr = sys.argv[1]
btInRange = True
screenLocked = False
counter = 0
if VERBOSE:
print "Identifying device..."
print bluetooth.lookup_name(btaddr, timeout=10)
try:
if bluetooth.lookup_name(btaddr, timeout=10):
if VERBOSE:
print 'OK: Your device is active.'
else:
if VERBOSE:
print 'Your device is inactive.'
print 'Activate your device and try again.'
sys.exit(1)
identify = bluetooth.lookup_name(btaddr, timeout=5).strip()
if identify:
if VERBOSE:
def main():
parser = argparse.ArgumentParser(
description=
'Read battery values of the Samsung Galaxy Buds, Buds+, Buds Live or Buds Pro'
'[Left, Right, Case (Buds+ or later)]')
parser.add_argument('mac',
metavar='mac-address',
type=str,
nargs=1,
help='MAC-Address of your Buds')
parser.add_argument('-m',
'--monitor',
action='store_true',
help="Notify on change")
parser.add_argument('-t',
'--monitor-timestamp',
action='store_true',
help="Notify on change and print timestamps")
parser.add_argument('-w',
'--wearing-status',
action='store_true',
help="Print wearing status instead")
parser.add_argument('-v',
'--verbose',
action='store_true',
help="Print debug information")
args = parser.parse_args()
verbose = args.verbose
if verbose:
print("Checking device model...")
islegacy = "Galaxy Buds (" in str(bluetooth.lookup_name(args.mac[0]))
if verbose:
print(str(bluetooth.lookup_name(args.mac[0])))
print("Searching for RFCOMM interface...")
uuid = ("00001101-0000-1000-8000-00805F9B34FB"
if not islegacy else "00001102-0000-1000-8000-00805f9b34fd")
service_matches = bluetooth.find_service(uuid=uuid,
address=str(args.mac[0]))
port = host = None
for match in service_matches:
if match["name"] == b"GEARMANAGER":
port = match["port"]
host = match["host"]
break
if port is None or host is None:
print("Couldn't find the proprietary RFCOMM service")
sys.exit(1)
if verbose:
print("RFCOMM interface found. Establishing connection...")
sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
sock.connect((host, port))
if verbose:
print("Connected. Waiting for incoming data...")
try:
while True:
data = sock.recv(1024)
if len(data) == 0:
break
if args.wearing_status:
success = parse_message_wear_status(data, islegacy,
args.monitor_timestamp)
else:
success = parse_message(data, islegacy, args.monitor_timestamp)
if success and not args.monitor and not args.monitor_timestamp:
exit(0)
except IOError:
pass
#!/usr/bin/python3
import bluetooth
target_name = "CAT S31"
target_address = None
print("scanning for nearby bluetooth devices...")
nearby_devices = bluetooth.discover_devices()
print("checking for " + target_name + " device...")
for device in nearby_devices:
if bluetooth.lookup_name(device) == target_name:
target_address = device
break
if target_address is not None:
print("found target bluetooth device with address ", target_address)
else:
print("could not find target bluetooth device nearby")
