def ble_find(pipe0, pipe1):
    i = 0
    while True:
        if i == 0:
            service_matches = bluetooth.find_service(
                address="00:1B:10:F1:FB:D4")
            while len(service_matches) == 0:
                service_matches = bluetooth.find_service(
                    address="00:1B:10:F1:FB:D4")
                time.sleep(0.5)
            print "find ok"
            i = 1
            pipe0.send(1)  #扫描到会向数据处理程序发送信号,提示可以进行蓝牙连接
            print "send ok"
        if i == 1:
            #在没有收到信号时
            rlist, wlist, elist = select.select(
                [
                    pipe0,
                    pipe1,
                ],
                [],
                [],
            )
            for fd in rlist:
                if fd == pipe0:
                    i = pipe0.recv()
                    print "A"
                if fd == pipe1:
                    i = pipe1.recv()
                    print "B"
    def run(self):
        print('Start send sms')
        if self.sms is None or self.sms.is_empty():
            print('Missing required argument sms, or not sms is empty')
            self.done.emit()
            self.terminate()
            return

        address = self.sms.device.host
        dun_port = 0

        services = bluetooth.find_service(address=address)

        # for service in services:
        #     if service["name"] == "Dial-up Networking":
        #         dun_port = service["port"]
        #         print("BT Profile: %s" % service["name"])
        #         print(" Host: %s" % service["host"])
        #         print(" Description: %s" % service["description"])
        #         print(" Provided By: %s" % service["provider"])
        #         print(" Protocol: %s" % service["protocol"])
        #         print(" channel/PSM: %s" % service["port"])
        #         print(" service classes: %s " % service["service-classes"])
        #         print(" profiles: %s " % service["profiles"])
        #         print(" service id: %s " % service["service-id"])
        dial_up = bluetooth.find_service(address=address,
                                         uuid=bluetooth.DIALUP_NET_CLASS)
        if len(dial_up):
            dun_port = dial_up[0]['port']

        if dun_port is 0:
            self.error.emit(self.NO_SERVICE_FOUND)
            self.done.emit()
            self.terminate()
            return

        socket = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
        connection = socket.connect((address, dun_port))

        socket.send("AT\r")
        print(socket.recv(1024))

        socket.send("AT+CMGF=1\r")
        print(socket.recv(1024))
        socket.send('AT+CMGS="' + self.sms.to_phone + '"\r')
        print(socket.recv(1024))
        socket.send(self.sms.message + chr(26))
        print(socket.recv(1024))
        print(socket.recv(1024))
        socket.close()

        self.sms.complete = True
        self.done.emit()
Exemple #3
0
def bluetooth():
    service_matches = bluetooth.find_service(address="00:1B:10:F1:FB:D4")
    while len(service_matches) == 0:
        print "couldn't find the FooBar service"
        service_matches = bluetooth.find_service(address="00:1B:10:F1:FB:D4")
        time.sleep(1)
    first_match = service_matches[0]
    port = first_match["port"]
    name = first_match["name"]
    host = first_match["host"]
    print "connecting to \"%s\" on %s port:%s" % (name, host, port)
    return port
Exemple #4
0
 def discover(self,id=False,name=False):
     devices = bluetooth.discover_devices(lookup_names=True)
     if len(devices) > 0:
         services = bluetooth.find_service()
     if id:
         for device in devices:
             if device[0] == id:
                 localservices = list()
                 for service in services:
                     if service['host'] == device[0]:
                         localservices.append(service)
                 self.send(["OK",device,localservices],"outbox")
                 break
         else:
             self.send(["ERROR",id])
     elif name:
         for device in devices:
             if device[1] == name:
                 localservices = list()
                 for service in services:
                     if service['host'] == device[0]:
                         localservices.append(service)
                 self.send(["OK",device,localservices],"outbox")
                 break
         else:
             self.send(["ERROR",name])
     else:
         if len(devices) == 0:
             self.send(["ERROR","No Devices Found"],"outbox")
         else:
             self.send([devices,services],"outbox")
def services():
    '''
        Modulo para descubrir los servicios de un dispositivo
    '''
    print 'Give me an address bluetooth'
    addr = raw_input('>> ')
    target = addr

    try:
        services = bluetooth.find_service(address=target)
    except:
        services = ''
    if len(services) > 0:
        print '[!] Found %d services on %s\n' % (len(services),target)
    else:
        print 'No services found'
        return 
    print '---------------------------------------------------'
    for svc in services:
        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 ''
    print '---------------------------------------------------'
Exemple #6
0
 def run(self):
     while True:
         info = self._person_info_queue.get()
         if isinstance(info, str):
             message = json.dumps({'umanPersonID': info})
         else:
             message = json.dumps({
                 'umanPersonID': ', '.join(info['umanPersonID']),
                 'givenName': ', '.join(info['givenName']),
                 'sn': ', '.join(info['sn']),
                 'mail': ', '.join(info['mail']),
                 'ou': ', '.join(info['ou']),
                 'employeeType': ', '.join(info['employeeType'])
             })
         _logger.info('Sending: %s', message)
         try:
             service_matches = bluetooth.find_service(uuid=SWIPE_UP_UUID, address=self._address)
             if service_matches:
                 first_match = service_matches[0]
                 if service_matches:
                     socket = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
                     socket.connect((first_match["host"], first_match["port"]))
                     socket.send(message + '\n')
                     socket.close()
                     time.sleep(1)
                 else:
                     _logger.error('Could not find service.')
             else:
                 _logger.error('Service not found.')
         except Exception as e:
             _logger.error("Failed to request signature from SwipeUp: %s", e)
         else:
             _logger.debug("Request for signature made to SwipeUp: %s", message)
         self._person_info_queue.task_done()
Exemple #7
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 connect(self, address):
		services = bluetooth.find_service(uuid = '1101', address = address)
		port = services[0]["port"]
		name = services[0]["name"]
		host = services[0]["host"]
		self.socket = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
		self.socket.connect((host, port))
    def findSerialDevices(self):
        devices = bluetooth.discover_devices(duration=5, lookup_names=False, flush_cache=True)

        serialDevices = []
        for address in devices:
            services = bluetooth.find_service(uuid=bluetooth.SERIAL_PORT_CLASS, address=address)
            services.extend(bluetooth.find_service(uuid=bluetooth.DIALUP_NET_CLASS))

            for service in services:
                serialDevices.append(
                    BluetoothDevice(
                        service["host"], service["port"], bluetooth.lookup_name(service["host"]), service["name"]
                    )
                )

        return serialDevices
    def run(self):
        self.device.updating = True

        services = []
        while len(services) is 0 and self.retry > 0:
            services = bluetooth.find_service(address=self.device.host)
            if len(services) > 0:
                self.retry = 0

        if len(services) is 0:
            print('No services found for device, stop connect')
            self.device.updating = False
            self.error.emit(self.NO_SERVICE_FOUND)
            self.done.emit()
            return

        a = json.dumps(services)

        self.device.services = services

        # If device not yet know it's manufacturer it's first connect
        if len(self.device.vendor) == 0:
            pnp_info_service = self.device.get_service_by_name('PnPInformation')
            if pnp_info_service:
                print('PnpService found')

        self.device.updating = False
Exemple #11
0
    def lookUpForDUN(self):
        # Look up for services offerted by the mobile device choosed
        services = bluetooth.find_service(address=self.address)
        # Sometimes there's no services offerted, so we need to know that
        if len(services) > 0:
            self.info = self.tr('Please wait ...\n')
            self.info += self.tr(
                'Looking for Dial-up networking service...\n\n')
            for service in services:
                # The service name can be found in three ways
                name = service["name"]
                if name == "Dial-up networking" or name == "Dial-Up Networking" or name == "Dial-up Networking":
                    # Store the port
                    self.channel = service["port"]
                    self.info += self.tr(
                        "Found Dial-up networking at channel ")
                    self.info += self.channel
                    message_title = self.tr("Information")
                    QMessageBox.information(self, message_title, self.info)
                    break
        else:
            error = self.tr(
                "No available services\nTry another device, please.")
            message_title = self.tr("Error message")
            QMessageBox.critical(self, message_title, error)
            return

        # There's no Dial-up networking
        if self.channel == 0:
            error = self.tr(
                "No Dial-up networking service detected!\nTry another device, please."
            )
            message_title = self.tr("Error message")
            QMessageBox.critical(self, message_title, error)
            return
Exemple #12
0
def sdpbrowse(macid=None):
    # this function determines the available service profiles at the specified bluetooth macid.
    target = macid
    print "Determining service profiles at " + str(target)
    if target == "all":
        target = None

    services = bluetooth.find_service(address=target)

    if len(services) > 0:
        print ("found %d services on %s" % (len(services), target))
        print ()
    else:
        print ("no services found")

    for svc in services:
        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 ()
 def find_bluetooth_services(self):
     services = bluetooth.find_service(address=self.bluetooth_address)
     if len(services) > 0:
         print("found %d services on %s" % (len(services), self.bluetooth_address))
         print(services)
     else:
         print("no services found")
Exemple #14
0
def is_phone_present(phone, service=HEADSET):
    try:
        phone_present = len(bluetooth.find_service(address=phone, name=service))
    except Exception as e:
        phone_present = 0
        print("Got exception %s in is_phone_present() - ignoring" % e)
    return phone_present > 0
Exemple #15
0
def scan_services():

    print("Scanning for bluetooth devices: ")

    devices = bluetooth.discover_devices(lookup_names=True)

    number_of_devices = len(devices)

    print(number_of_devices, "devices found")

    for addr, name in devices:

        print("\n")

        print("Device Name: %s" % (name))

        print("Device MAC Address: %s" % (addr))

        print("Services Found:")

        services = bluetooth.find_service(address=addr)

        if len(services) <= 0:

            print("zero services found on", addr)

        else:

            for serv in services:

                print(serv['name'])

        print("\n")

    return
Exemple #16
0
def main(text):

    vals = []
    for t in text:
        try:
            pat = character_map[t]
            vals.append(pat)
        except ValueError:
            print( 'VAlue %s, not recognized' %t)
            raise

    service_matches = bluetooth.find_service(uuid=uuid, address=serverMACAddress)
    
    if len(service_matches) == 0:
        print("Couldn't find the SampleServer service.")
        sys.exit(0)

    first_match = service_matches[0]
    port = first_match["port"]
    name = first_match["name"]
    host = first_match["host"]
    
    print(first_match)
    
    s = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
    s.connect((serverMACAddress, port))
    s.send(bytes([len(vals)] + vals))
Exemple #17
0
def start_client():
    print("Starting Client...")
    service_matches = bluetooth.find_service(uuid=uuid, address=None)

    if len(service_matches) == 0:
        print("Couldn't find the SampleServer service.")
        sys.exit(0)

    first_match = service_matches[0]
    port = first_match["port"]
    name = first_match["name"]
    host = first_match["host"]

    print("Connecting to \"{}\" on {}".format(name, host))

    # Create the client socket
    sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
    sock.connect((host, port))

    print("Connected. Type something...")
    while True:
        data = input()
        if not data:
            break
        sock.send(data)

        if data == "q":
            break

    sock.close()
def service_discover(device):
    services = blue.find_service(address=device)
    for service in services:
        name = str(service['name'])
        protocol = str(service['protocol'])
        port = str(service['port'])
        print("[+] found service: [{}][{}][{}]".format(name, protocol, port))
	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)
Exemple #20
0
    def _create_client(self):
        assert self.uuid is not None
        logger.info("searching service %s (UUID: %s) @ %s" %
                    (self.name, self.uuid, self.upstream_addr or 'anywhere'))

        service_matches = []
        while len(service_matches) == 0:
            try:
                service_matches = bt.find_service(uuid=self.uuid,
                                                  address=self.upstream_addr)
                if len(service_matches) == 0:
                    sleep(1)
            except KeyboardInterrupt:
                break

        first_match = service_matches[0]
        port = first_match["port"]
        name = first_match["name"]
        host = first_match["host"]

        logger.info("connecting to App \"%s\" on %s" % (name, host))

        # Create the client socket
        sock = BluetoothSocket(bt.RFCOMM)
        sock.connect((host, port))
        return sock
Exemple #21
0
    def spp_client(self):

        global G_connected
        print("BT: start spp client")
        print(f"BT: search for spp server on {self.addr}")

        uuid = UUID_SPP
        services = bluetooth.find_service(uuid=uuid, address=self.addr)

        if len(services) == 0:
            print("BT: could not find spp server")
            G_connected = False
            return

        s = services[0]
        port = s['port']
        name = s['name']
        host = s['host']
        print(f"BT: connect to {name} on {host}")

        self.sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
        self.sock.connect((host, port))
        print("BT: connected")
        G_connected = True

        #---- thread ----
        self.thread = BtRxThread(self.sock)
        self.thread.start()
        return
    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)
Exemple #23
0
def connect(addr):
    services = bluetooth.find_service(address=addr)
    if len(services) > 0:
        print("found %d services" % len(services))
        print()
    else:
        print("no services found")

    for svc in services:
        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()

        host = svc["host"]
        port = svc["port"]
        import binascii
        print binascii.hexlify(svc["name"])
        if svc["protocol"] == "RFCOMM" and svc["name"] == "AMP-SPP\x00":
            print("Trying to connect")
            sock=bluetooth.BluetoothSocket( bluetooth.RFCOMM )
            sock.connect((host, port))
            total_size = 0
            while True:
                data = sock.recv(1024)
                total_size += len(data)
                print "received [%s], size %i" % (data, total_size)
            sock.close()
Exemple #24
0
    def scanservices(self):
        logging.info("Searching for services...")
        if system() == "Darwin":
            return self.scanservices_osx()

        # Example find_service() output on raspbian buster:
        # {'service-classes': ['1101'], 'profiles': [], 'name': 'Port', 'description': None,
        #  'provider': None, 'service-id': None, 'protocol': 'RFCOMM', 'port': 1,
        #  'host': 'A1:B2:C3:D4:E5:F6'}
        service_matches = find_service(uuid=self.service_uuid,
                                       address=self.address)
        valid_service = list(
            filter(
                lambda s: 'protocol' in s and 'name' in s and s[
                    'protocol'] == 'RFCOMM' and
                (s['name'] == 'SerialPort' or s['name'] == 'Port'),
                service_matches))
        print(valid_service[0])
        if len(valid_service) == 0:
            logging.error("Cannot find valid services on device with MAC %s." %
                          self.address)
            return False
        logging.info("Found a valid service")
        self.service = valid_service[0]
        return True
	def send(self, messageToSend, destinationServiceName, destinationMAC, destinationUUID):
		logger.write('DEBUG', '[BLUETOOTH] Buscando el servicio \'%s\'.' % destinationServiceName)
		# Buscamos un servicio Bluetooth específico
		serviceMatches = bluetooth.find_service(uuid = destinationUUID, address = destinationMAC)
		# Verificamos si hubo alguna coincidencia
		if len(serviceMatches) > 0:
			try:
				firstMatch = serviceMatches[0]
				name = firstMatch['name']
				host = firstMatch['host']
				port = firstMatch['port']
				# Crea un nuevo socket Bluetooth que usa el protocolo de transporte especificado
				clientSocket = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
				# Conecta el socket con el dispositivo remoto (host) sobre el puerto (channel) especificado
				clientSocket.connect((host, port))
				logger.write('DEBUG', '[BLUETOOTH] Conectado con la dirección \'%s\'.' % host)
				return self.bluetoothTransmitter.send(messageToSend, clientSocket)
			except bluetooth.btcommon.BluetoothError as bluetoothError:
				# (11, 'Resource temporarily unavailable')
				# (16, 'Device or resource busy')
				logger.write('WARNING','[BLUETOOTH] %s.' % bluetoothError)
				return False
		else:
			logger.write('DEBUG', '[BLUETOOTH] No se pudo encontrar el servicio \'%s\'.' % destinationServiceName)
			return False
Exemple #26
0
    def find_service(self,
                     name: str = None,
                     addr: str = None,
                     uuid: str = None) -> BluetoothLookupServiceResponse:
        """
        Look up for a service published by a nearby bluetooth device. If all the parameters are null then all the
        published services on the nearby devices will be returned. See
        `:class:platypush.message.response.bluetoothBluetoothLookupServiceResponse` for response structure reference.

        :param name: Service name
        :param addr: Service/device address
        :param uuid: Service UUID
        """

        import bluetooth
        from bluetooth import find_service
        services = find_service(name=name, address=addr, uuid=uuid)

        self._port_and_protocol_by_addr_and_srv_uuid.update({
            (srv['host'], srv['service-id']):
            (srv['port'], getattr(bluetooth, srv['protocol']))
            for srv in services if srv.get('service-id')
        })

        self._port_and_protocol_by_addr_and_srv_name.update({
            (srv['host'], srv['name']):
            (srv['port'], getattr(bluetooth, srv['protocol']))
            for srv in services if srv.get('name')
        })

        return BluetoothLookupServiceResponse(services)
Exemple #27
0
def sendOut(port,text):
	backlog = 1
	size = 1024
	#Needs a loop somehow
	others = bluetooth.find_service(name='spartacus')
	for other in others:
		thread.start_new_thread( beClient, (other['host'],port,text) )
Exemple #28
0
def sdpBrowse(addr):
    services = bluetooth.find_service(address=addr)
    for service in services:
        name = service['name']
        proto = service['protocol']
        port = str(service['port'])
        print('[+] Found ' + str(name)+' on '+ str(proto) + ':'+port)
Exemple #29
0
 def __init__(self, mac, uuid="00001101-0000-1000-8000-00805f9b34fb"):
     self.uuid = uuid
     self.mac = mac
     self.service = bluetooth.find_service(uuid=uuid, address=mac)
     if len(self.service) < 1:
         raise Exception("Could not find Bluetooth service!")
     self.sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
Exemple #30
0
    def do_connect(self, line, opts={}):
        """Connects to BIP Server"""
        server_address = line
        if not server_address:
            raise TypeError("server_address cannot be empty")
        logger.info("Finding BIP service ...")
        services = bluetooth.find_service(address=server_address,
                                          uuid=headers.COVERART_UUID)
        if not services:
            sys.stderr.write("No BIP (CoverArts) service found\n")
            sys.exit(1)

        host = services[0]["host"]
        port = services[0]["port"]
        logger.info("BIP service found!")

        self.client = BIPClient(host, port)
        logger.info("Connecting to bip server = (%s, %s)", host, port)
        result = self.client.connect(
            header_list=[headers.Target(headers.COVERART_UUID)])
        if not isinstance(result, responses.ConnectSuccess):
            logger.error("Connect Failed, Terminating the bip client..")
            sys.exit(2)
        logger.info("Connect success")
        self.prompt = self.colorize("bip> ", "green")
    def __init__(self, strType):

        if strType == 'bluez':
            bd_addr = "00:1A:7D:DA:71:05"
            port = bluetooth.find_service(name = "ADC Service")[0]['port']
            try:
                self.sock=bluetooth.BluetoothSocket( bluetooth.RFCOMM )
                self.sock.connect((bd_addr, port))
            except bluetooth.btcommon.BluetoothError as error:
                print "Could not connect: ", error
                sys.exit(1)

        elif strType == 'tcp':
            host = socket.gethostbyname("raspberrypi")
            port = 6789

            try:
               self.sock = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
            except socket.error, msg:
               self.sock = None
            try:
               self.sock.connect((host,port)) # Verbinden
            except socket.error, msg:
               self.sock.close()
               self.sock = None
    def call_service(self):
        r = rospy.Rate(1 / 3.0)
        rospy.loginfo("connecting to service {}...".format(self.uuid))
        while not rospy.is_shutdown():
            service_matches = bluetooth.find_service(uuid=self.uuid,
                                                     address=self.faddr)
            if len(service_matches) == 0:
                rospy.loginfo(
                    "couldn't find the service = {}, try again".format(uuid))
            else:
                rospy.loginfo("service found")
                break

            r.sleep()

        first_match = service_matches[0]
        port = first_match["port"]
        name = first_match["name"]
        host = first_match["host"]

        rospy.loginfo("connecting to {} on {} on port {}".format(
            name, host, port))
        sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
        sock.connect((host, port))

        return sock
Exemple #33
0
    def sdp(self, target):

        print("BT: sdp begin")

        if target == 'all':
            target = None
        services = bluetooth.find_service(address=target)

        if len(services) > 0:
            print("BT: found %d services on %s" % (len(services), target))
        else:
            print("BT: no services found")

        for s in services:
            print("service name: %s" % (s['name']))
            print("host: %s" % (s['host']))
            print("description: %s" % (s['description']))
            print("provider: %s" % (s['provider']))
            print("protocol: %s" % (s['protocol']))
            print("channel/psm: %s" %
                  (s['port']))  # psm - protocol and service multiplexer
            print("profiles: %s" % (s['profiles']))
            print("service classes: %s" % (s['service-classes']))
            print("service id: %s" % (s['service-id']))

        print("BT: sdp end")
        return
def find_free_ports(target='localhost'):
    free_ports=range(1,31)
    services = bluetooth.find_service(address=target)
    for svc in services:
         if svc['port'] in free_ports:
           free_ports.remove(svc['port'])
    return free_ports
    def connect(self, hardware_address=None):
        if self.listerner is not None:
            # Set state
            self.listerner.on_state_changed(self.CONNECTION_STATE_CONNECTING)
            logger.debug(f"Connect to server on {hardware_address}")
            # service_matches = bluetooth.find_service(uuid=self.uuid)
            service_matches = bluetooth.find_service(uuid=self.uuid, address=hardware_address)
            if len(service_matches) == 0:
                logger.error("Couldn't find the RFCOMM service.")
                sys.exit(1)

            first_match = service_matches[0]
            port = first_match["port"]
            name = first_match["name"]
            host = first_match["host"]

            logger.info(f"Connecting to '{name}' on {host}:{port}")

            # Create the client socket
            self.sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
            try:
                self.sock.connect((host, port))
                self.listerner.on_connect_success(param_string=name)
                self.listerner.on_state_changed(self.CONNECTION_STATE_CONNECTED)
            except Exception as e:
                self.listerner.on_state_changed(self.CONNECTION_STATE_NONE)
                self.listerner.on_connect_failed(e)

            self.start_communication()
        else:
            logger.debug("No ChatListener attached!!")
            sys.exit(1)
Exemple #36
0
	def __init__(self,addr=None):
		uuid = "0ef0f502-f0ee-46c9-986c-54ed027807fb"

		service_matches = bluetooth.find_service( uuid = uuid, address = addr )

		if len(service_matches) == 0:
		    print "Failed to find Parrot Zik RFCOMM service"
		    self.sock =""
		    return

		first_match = service_matches[0]
		port = first_match["port"]
		name = first_match["name"]
		host = first_match["host"]

		print "Connecting to \"%s\" on %s" % (name, host)

		self.sock=bluetooth.BluetoothSocket( bluetooth.RFCOMM )
		self.sock.connect((host, port))

		self.sock.send('\x00\x03\x00')
		data = self.sock.recv(3)

		self.BatteryLevel = 100
		self.BatteryCharging = False
		print "Connected"
 def entity2uuid(entity_id):
     """
     Return all the UUIDs (i.e. SDP service-id) for the device with
     the given MAC
     """
     services = bluetooth.find_service(address=entity_id)
     return [ uuid.UUID(svc['service-id']) for svc in services if svc['service-id'] ]
Exemple #38
0
def connect(hardware_address):
    logger.debug(f"Connect to server on {hardware_address}")
    service_matches = bluetooth.find_service(
        uuid="00001101-0000-1000-8000-00805F9B34FB", address=hardware_address)
    # logger.debug(service_matches)
    if len(service_matches) == 0:
        logger.error("Couldn't find the RFCOMM service.")
        sys.exit(1)

    first_match = service_matches[0]
    port = first_match["port"]
    name = first_match["name"]
    host = first_match["host"]

    logger.info(f"Connecting to '{name}' on {host}:{port}")

    # Create the client socket
    socket = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
    try:
        logger.debug(socket.connect((host, port)))
        logger.debug("CONNECTED")
    except Exception as e:
        logger.exception(e)
        raise e

    return socket
 def __supports_push(self, address):
     ##
     # first look in cache
     ##
     if not self.__cache == None:
         device = self.__cache.get(address)
         if not device == None:
             if(device.supports_obex() == True):
                 self.__logger.debug("# * Found in cache")
                 return device.get_service()    
     ##
     # Do a double search with different libraries to ensure support
     ##
     # Nokia "OBEX Object Push"
     # Android "Object Push"
     ##
     all_services = bluetooth.find_service(address=address)
     if not all_services == None:
         for services in all_services:
             if not services["name"] == None:
                 #print "%s %s" % (services["name"], services["port"])
                 if(services["name"].find("Object Push")>=0):
                     return {"host": str(address), "port":services["port"]}
     services = lightblue.findservices(addr=address, name=None, servicetype=_lightbluecommon.OBEX)
     if(services != None):
         for service in services:
             if not service[2] == None:
                 if(services[2].find("Object Push")>=0):
                     return {"host": str(address), "port":service[1]}
     return None
Exemple #40
0
def RFCOMM_Sendfile(address, fname="test.txt", fdata=b'Hello world\n'):

    print("Searching for OBEX service on %s" % address)

    # Use the server named "OBEX Object Push" to send file
    service_matches = bluetooth.find_service(name="OBEX Object Push",
                                             address=address)
    if len(service_matches) == 0:
        print("Couldn't find the service")
        sys.exit(0)

    match = service_matches[0]
    name = match["name"]
    host = match["host"]
    port = match["port"]

    print("Service Name: %s" % match["name"])
    print("    Host:        %s" % match["host"])
    print("    Description: %s" % match["description"])
    print("    Provided By: %s" % match["provider"])
    print("    Protocol:    %s" % match["protocol"])
    print("    channel/PSM: %s" % match["port"])
    print("    svc classes: %s " % match["service-classes"])
    print("    profiles:    %s " % match["profiles"])
    print("    service id:  %s " % match["service-id"])

    print("Connecting to \"%s\" on %s" % (name, host))
    client = Client(host, port)
    client.connect()

    # The parameter [file_data] must be bytes type like [b'****'],otherwise there will be some error occur in Python3
    client.put(name=fname, file_data=fdata)
    client.disconnect()

    return
Exemple #41
0
    def do_connect(self, line, opts):
        profile_id = "1130"  # profile id of PBAP
        service_id = "\x79\x61\x35\xf0\xf0\xc5\x11\xd8\x09\x66\x08\x00\x20\x0c\x9a\x66"
        server_address = line
        if not server_address:
            raise ValueError("server_address should not be empty")
        logger.info("Finding PBAP service ...")
        services = bluetooth.find_service(address=server_address,
                                          uuid=profile_id)
        if not services:
            sys.stderr.write("No PBAP service found\n")
            sys.exit(1)

        host = services[0]["host"]
        port = services[0]["port"]
        logger.info("PBAP service found!")

        self.client = PBAPClient(host, port)
        logger.info("Connecting to pbap server = (%s, %s)", host, port)
        result = self.client.connect(header_list=[headers.Target(service_id)])
        if not isinstance(result, responses.ConnectSuccess):
            logger.error("Connect Failed, Terminating the Pbap client..")
            sys.exit(2)
        logger.info("Connect success")
        self.prompt = self.colorize("pbap> ", "green")
    def find_bt_services(self, name=None, uuid=None, address=None):
        """
        Shows services supported by target device (by name/uuid/address)
        or shows services for all near devices if None is provided.
        """
        print "\nLooking for BlueTooth services...\n"
        if address:
            if not self.check_address_validity(address):
                # should not try to connect if address is not valid
                print "\nExiting..."
                sys.exit(0)

        self.bt_services = bluetooth.find_service(name, uuid, address)

        if self.bt_services:
            for service in self.bt_services:
                print "Service Name: %s" % service["name"]
                print " Host:        %s" % service["host"]
                print " Description: %s" % service["description"]
                print " Provided By: %s" % service["provider"]
                print " Protocol:    %s" % service["protocol"]
                print " Channel/PSM: %s" % service["port"]
                print " Svc classes: %s" % service["service-classes"]
                print " Profiles:    %s" % service["profiles"]
                print " Service ID:  %s" % service["service-id"]
                print "--------------------------------------------"
        else:
            print "No BlueTooth services were found."
Exemple #43
0
def send_bluetooth_to_device(my_thread):
    uuid = "94f39d29-7d6d-437d-973b-fba39e49d4ee"  # arbitrary set
    service_matches = bluetooth.find_service(uuid=uuid, address=addr)

    if len(service_matches) == 0:
        print("Couldn't find the SampleServer service.")
        sys.exit(0)

    first_match = service_matches[0]
    port = first_match["port"]
    name = first_match["name"]
    host = first_match["host"]

    print("Connecting to \"{}\" on {}".format(name, host))

    # Create the client socket
    sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
    sock.connect((host, port))

    print("Connected. Type something...")
    while True:
        data = my_thread.read_data_out()
        if not data:
            break
        sock.send(data)
        my_thread.yield()

    sock.close()
Exemple #44
0
    def connect(self):
        if self.sock:
            return True

        service_matches = bluetooth.find_service(
            address=self.addr, uuid=bluetooth.SERIAL_PORT_CLASS)
        if len(service_matches) == 0:
            self.printError("BT device not found.")
            return False

        first_match = service_matches[0]
        self.port = first_match["port"]
        self.name = first_match["name"]
        self.host = first_match["host"]

        self.sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
        try:
            ret = self.sock.connect((self.addr, self.port))
        except bluetooth.btcommon.BluetoothError as e:
            self.printError(e)
            self.sock.close()
            self.sock = None
            return False

        self.printWarning("Connected to \"{}\" on {} port {}".format(
            self.name, self.host, self.port))
        self.sock.settimeout(0.3)
        return True
Exemple #45
0
def dowork(device_address):
    services = bluetooth.find_service(address=device_address, uuid="1105",)
    port = None

    if services:
        port = services[0]["port"]

    if not port:
      print "Service not provided"
      return

    print "Connecting to", device_address, port
    c = client.Client(device_address, port)

    response = c.connect()
    if not isinstance(response, responses.ConnectSuccess):
        print "Failed to connect"
        return

    reply = c.get(header_list=[headers.Type("text/x-vcard"),])[1]
    if reply and type(reply)==str:
      result = VCard(reply)
      print result.values
      doput(c)

    c.disconnect()
Exemple #46
0
 def connect(self, address):
     services = bluetooth.find_service(uuid='1101', address=address)
     port = services[0]["port"]
     name = services[0]["name"]
     host = services[0]["host"]
     self.socket = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
     self.socket.connect((host, port))
Exemple #47
0
def dowork(device_address):
    services = bluetooth.find_service(
        address=device_address,
        uuid="1105",
    )
    port = None

    if services:
        port = services[0]["port"]

    if not port:
        print "Service not provided"
        return

    print "Connecting to", device_address, port
    c = client.Client(device_address, port)

    response = c.connect()
    if not isinstance(response, responses.ConnectSuccess):
        print "Failed to connect"
        return

    reply = c.get(header_list=[
        headers.Type("text/x-vcard"),
    ])[1]
    if reply and type(reply) == str:
        result = VCard(reply)
        print result.values
        doput(c)

    c.disconnect()
	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 find_bt_services(self, name=None, uuid=None, address=None):
        """
        Shows services supported by target device (by name/uuid/address)
        or shows services for all near devices if None is provided.
        """
        print "\nLooking for BlueTooth services...\n"
        if address:
            if not self.check_address_validity(address):
                # should not try to connect if address is not valid
                print "\nExiting..."
                sys.exit(0)

        self.bt_services = bluetooth.find_service(name, uuid, address)

        if self.bt_services:
            for service in self.bt_services:
                print "Service Name: %s" % service["name"]
                print " Host:        %s" % service["host"]
                print " Description: %s" % service["description"]
                print " Provided By: %s" % service["provider"]
                print " Protocol:    %s" % service["protocol"]
                print " Channel/PSM: %s" % service["port"]
                print " Svc classes: %s" % service["service-classes"]
                print " Profiles:    %s" % service["profiles"]
                print " Service ID:  %s" % service["service-id"]
                print "--------------------------------------------"
        else:
            print "No BlueTooth services were found."
Exemple #50
0
def setup_bluetooth_socket(addr):
    # search for the SampleServer service
    # uuid = "94f39d29-7d6d-437d-973b-fba39e49d4ee"
    # uuid = "MakeBlock"
    # service_matches = find_service( uuid = uuid, address = addr )
    # service_matches = find_service( name = uuid, address = addr )
    #import pdb;pdb.set_trace()
    print('addr: {}'.format(addr))
    service_matches = bluetooth.find_service(address=addr)

    print('All service matches:')
    print(service_matches)
    if len(service_matches) == 0:
        print("couldn't find the Origibot2 bluetooth service =(")
        sys.exit(0)

    first_match = service_matches[0]
    port = first_match["port"]
    name = first_match["name"]
    host = first_match["host"]

    print("connecting to \"%s\" on %s" % (name, host))

    # Create the client socket
    global sock
    sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
    sock.connect((host, port))
Exemple #51
0
def find_services(addr):
     data ='['
     for services in bluetooth.find_service(address = addr):
         data+= '{"name":"'+str(services["name"])+'","description":"'+str(services["description"])+'"'
         data+=',"provider":"'+str(services["provider"])+',"protocol":"'+str(services["protocol"])+'"'
         data+=',"port":"'+str(services["port"])+',"service-id":"'+str(services["service-id"])+'"}'
     data+=']'
     return data
Exemple #52
0
def service_discover(addr):

    services = bluetooth.find_service(address=addr)

    if len(services) > 0:
        return services
    else:
        return "No Services"
    def __init__(self, strType):

        if strType == 'bluez':
            bd_addr = "00:1A:7D:DA:71:05"
            port = bluetooth.find_service(name = "ADC Service")[0]['port']

            self.sock=bluetooth.BluetoothSocket( bluetooth.RFCOMM )
            self.sock.connect((bd_addr, port))
 def connect_bluetooth_device(self, bd_addr):
     """ Connect to a Bluetooth device specified by the bd_addr address
         and display the control view for the device.
     """
     service = bluetooth.find_service(uuid=CELLBOT_UUID, address=bd_addr)[0]
     self.socket = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
     self.socket.connect((service["host"], service["port"]))
     self.droid.webViewShow(CONTROL_VIEW)
Exemple #55
0
 def find_service(self, serviceId, addr):
     isFound = False
     while (isFound == False):            
         target = bluetooth.find_service(address = addr, uuid = serviceId)
         if (len(target) > 0):
             return target[0]
             isFound = True
         time.sleep(1)
Exemple #56
0
def initRFCOMM():
	print("Scanning for devices (3s)...")
	devices = []
	try:
		devices = bluetooth.discover_devices(duration = 3, lookup_names = True)
	except Exception as e:
		print("Error: %s\n" % str(e))
		return None

	devicesLength = len(devices)

	print("Found %d devices!" % devicesLength)
	if devicesLength is 0:
		return None
	i = 0
	for addr, name in devices:
		print("%d: %s [%s]" % (i, name, addr))
		i+=1

	key = input("Enter index of device to connect to: ")
	try:
		key = int(key)
	except Exception as e:
		print("Bad input!")
		return None
	if (key < 0) or (key > devicesLength):
		print("Bad input!")
		return None

	(deviceAddr, deviceName) = devices[key]
	print("Searching for services on device: %s [%s]" % (deviceName, deviceAddr))
	services = bluetooth.find_service(address = deviceAddr)

	port = None
	if len(services) is 0:
		key = input("No services found, input port number: ")
		try:
			port = int(key)
		except Exception as e:
			print("Bad input!")
			return None
	else:
		for i in range(len(services)):
			print("%d: %s - Port: %s" % (i, services[i]["name"], services[i]["port"]))
		key = input("Enter index of service to conect to: ")
		try:
			key = int(key)
		except Exception as e:
			print("Bad input!")
			return None
		port = services[key]["port"]

	print("Connecting...")
	connection = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
	connection.connect((deviceAddr, port))
	connection.settimeout(5.0)
	print("Connected to %s (%s)" % connection.getpeername())
	return connection
Exemple #57
0
def find_port(host):
	services = bluetooth.find_service(address=host)
	for service in services:
		print service
		if service['name'] == 'SL4A':
			print service
			port = service['port']
			print port
			return port
Exemple #58
0
def find_ska_service(device_address=None):
    print('Searching for devices with the SKA secure service')
    service_matches = bluetooth.find_service(uuid=SKA_PAIRING_UUID, address=device_address)
    print 'Services found: ' + str(service_matches)

    if len(service_matches) == 0:
        print("couldn't find the SKA service =(")

    return service_matches
Exemple #59
-1
def debug_bt_bt():
    print "looking for nearby devices..."
    nearby_devices = bluetooth.discover_devices(lookup_names=True, flush_cache=True, duration=20)
    print "found %d devices" % len(nearby_devices)
    for addr, name in nearby_devices:
        print " %s - %s" % (addr, name)
        print_services(bluetooth.find_service(address=addr))