def advertise_service(self,name = 'bluetooth_server'): bluetooth.advertise_service(self.socket, name, service_id=self.uuid, service_classes=[uuid, bluetooth.SERIAL_PORT_CLASS], profiles=[bluetooth.SERIAL_PORT_PROFILE], # protocols = [ OBEX_UUID ] )
def handle_disconnection(self, serversocket, condition): """ Handles the shutdown of connections. When the serversocket signals the HUP condition. The handler disconnects from the mainloop by returning false. This method is called when the connection was shutdown from the otherside of the connection. The data handler (L{handle_incoming_data}) for incoming data is disconnected and the disconnect signal is fired. If we are in connectable or filtered mode, we will reattach the serversocket watch for gtk.IO_IN with L{handle_connection}) as handler. @type self: BTServer @param self: The BTServer object responsible for handling the connection @type serversocket: bluetooth.BluetoothSocket @param serversocket: A bluetooth socket responsible for handling incoming connections (server side) @type condition: integer (gobject.Enum) @param condition: The condition of the serversocket which caused the handler to be called should always be gobject.IO_HUP (=16) @rtype: bool @return: always False, as we only allow one concurrent connection """ gobject.source_remove(self.client_io_watch) self.server_io_watch = None self.client_io_watch = None self.client_sock = None self.emit("disconnect", self.connected[0], self.connected[1]) self.connected = None if self.connectable == 'yes' or self.connectable == 'filtered': self.server_io_watch = gobject.io_add_watch(self.server_sock, gobject.IO_IN, self.handle_connection) bluetooth.advertise_service(self.server_sock, self.name, self.serverid) return False
def runServer(): serverSocket = bluetooth.BluetoothSocket( bluetooth.RFCOMM ) port = bluetooth.PORT_ANY serverSocket.bind(("", port)) print "Listening for connections on port: ", port serverSocket.listen(1) port=serverSocket.getsockname()[1] #the missing piece bluetooth.advertise_service( serverSocket, "SampleServer", service_id = uuid, service_classes = [ uuid, bluetooth.SERIAL_PORT_CLASS ], profiles = [ bluetooth.SERIAL_PORT_PROFILE ] ) inputSocket, address=serverSocket.accept() print "Got connection with" , address last_data = 0.0 while True: data = inputSocket.recv(5) if float(data) > 1.29: k.tap_key("a") elif float(data) < -1.29: k.tap_key("d") print "received [%s] \n " % data inputSocket.close() serverSocket.close()
def __init__(self,uuid): """ Permet de créer un socket serveur """ try: # initialise un socket RFCOMM bluetooth.BluetoothSocket.__init__( self, bluetooth.RFCOMM ) # applique le socket sur le premier adaptateur trouvé, # et le premier port libre self.bind( ("",bluetooth.PORT_ANY) ) # commence l'écoute sur le port, avec une connection # en file d'attente au maximum self.listen(1) # averti le serveur SDP de la présence du serveur bluetooth.advertise_service( self, "Paquet",uuid,[uuid]) #variable interne self.creationReussie = True except OSError: #erreur dûe à pybluez (pas très descriptive...) #variable interne self.creationReussie = False #defini une valeure bidon d'addresse de serveur self.getsockname = lambda: ("XX:XX:XX:XX:XX:XX",0) #variable interne self.actif = True return #initialise la liste des connections self.connections = [] #variable interne self.actif = True
def advertise(servicename, sock, serviceclass): try: if serviceclass == _lightbluecommon.RFCOMM: bluetooth.advertise_service(sock._sock, servicename, service_classes=[bluetooth.SERIAL_PORT_CLASS], profiles=[bluetooth.SERIAL_PORT_PROFILE]) elif serviceclass == _lightbluecommon.OBEX: # for pybluez, socket do need to be listening in order to # advertise a service, so we'll call listen() here. This should be # safe since user shouldn't have called listen() already, because # obex.recvfile() docs state that an obex server socket should # *not* be listening before recvfile() is called (due to Series60's # particular implementation) if not sock._listening: sock.listen(1) # advertise Object Push Profile not File Transfer Profile because # obex.recvfile() implementations run OBEX servers which only # advertise Object Push operations bluetooth.advertise_service(sock._sock, servicename, service_classes=[bluetooth.OBEX_OBJPUSH_CLASS], profiles=[bluetooth.OBEX_OBJPUSH_PROFILE], protocols=["0008"]) # OBEX protocol else: raise ValueError("Unknown serviceclass, " + \ "should be either RFCOMM or OBEX constants") # set flag sock._advertised = True except bluetooth.BluetoothError, e: raise _lightbluecommon.BluetoothError(str(e))
def __init__(self,addOrigine,serviceInfo): """ crée le tunnel sur le service de "addOrigine" """ #récupère les infos self.origine = addOrigine if serviceInfo["protocol"] == "RFCOMM": self.protocole = bluetooth.RFCOMM elif serviceInfo["protocol"] == "L2CAP": self.protocole = bluetooth.L2CAP self.port = serviceInfo["port"] #crée un service correspondant bluetooth.BluetoothSocket.__init__(self, self.protocole) try: self.bind( ("",bluetooth.PORT_ANY) ) except OSError: print("[retransmission de "+self.origine+"] impossible") return #fais de la pub bluetooth.advertise_service(self,serviceInfo["name"], serviceInfo["service-id"], serviceInfo["service-classes"], serviceInfo["profiles"])
def try_connect(self): try: self.server_sock = bluetooth.BluetoothSocket( bluetooth.RFCOMM ) err = self.server_sock.bind(("", bluetooth.PORT_ANY)) err = self.server_sock.listen(1) self.port = self.server_sock.getsockname()[1] # advertise our service bluetooth.advertise_service( self.server_sock, "Freevused", service_classes = [ bluetooth.SERIAL_PORT_CLASS ], profiles = [ bluetooth.SERIAL_PORT_PROFILE ] ) logger.debug("Waiting for connection on RFCOMM channel %d", self.port) self.tx, self.address = self.server_sock.accept() logger.debug("Accepted connection") self.connected = True self.tx_dispatcher.register(self.tx.fileno(), kaa.IO_READ) except bluetooth.BluetoothError, e: self.connected = False logger.debug("broken tooth (try_connect): %s", str(e)) if self.server_sock: self.server_sock.close() self.server_sock = None
def run(self): log.info("btserver running") while self.running: self.server_sock = None try: self.server_sock = bt.BluetoothSocket(bt.RFCOMM) self.server_sock.setblocking(0) self.server_sock.bind(("", self.channel)) self.server_sock.listen(1) bt.advertise_service(self.server_sock, config.PNAME, service_classes = [bt.SERIAL_PORT_CLASS], profiles = [bt.SERIAL_PORT_PROFILE]) log.info("Waiting for connections on RFCOMM channel [{}]".format(self.server_sock.getsockname()[1])) while self.running: readable, _, _ = select.select([self.server_sock], [], [], 0.1) for s in readable: if s is self.server_sock: client_sock, client_info = self.server_sock.accept() log.info("Accepted connection from: " + str(client_info)) client_sock.setblocking(1) client_sock.settimeout(self.timeout) if self.running: conn = Connection(client_sock, self) conn.start() except: if self.running: log.exception("Error while listening for connections") time.sleep(1.0) finally: self.close()
def wait_for_connections(self): self.video_socket.listen(1) self.control_socket.listen(1) video_port = self.video_socket.getsockname()[1] control_port = self.control_socket.getsockname()[1] self.video_conn = None self.control_conn = None print "Listening on bluetooth." print "Video channel: %s" % (video_port,) print "Control channel: %s" % (control_port,) try: bluetooth.advertise_service(self.video_socket, "BotDriverVideo") except bluetooth.btcommon.BluetoothError: print ("Failed to advertise service. " "Is the Bluetooth daemon running?") # We'll go ahead and wait for connections using select() so we can # accept connections in any order. available_sockets = [self.video_socket, self.control_socket] while self.video_conn == None or self.control_conn == None: rlist, wlist, xlist = select.select( available_sockets, [], []) for sock in rlist: if sock == self.video_socket: self.video_conn, address = sock.accept() sock.close() print "Accepted connection from %s." % (address,) elif sock == self.control_socket: self.control_conn, address = sock.accept() sock.close() print "Accepted connection from %s." % (address,) available_sockets.remove(sock)
def hostServer(mac,port): backlog = 1 size = 1024 sock = bluetooth.BluetoothSocket( bluetooth.RFCOMM ) sock.bind(("",port)) sock.listen(backlog) bluetooth.advertise_service(sock,'spartacus',description = mac) s = socket.socket(socket.AF_BLUETOOTH, socket.SOCK_STREAM, socket.BTPROTO_RFCOMM) s.bind((mac,port)) s.listen(backlog) while True: try: client, address = s.accept() data = client.recv(size) if data: print(data) client.send(data) except Exception: print("Closing socket") break try: client.close() except Exception: pass s.close() sock.close()
def createConnection (): print ("Tratando de establecer conexion bluetooth") server_sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM) port = bluetooth.PORT_ANY server_sock.bind(("",port)) server_sock.listen(1) bluetooth.advertise_service(server_sock,"",service_classes=[bluetooth.SERIAL_PORT_CLASS],profiles=[bluetooth.SERIAL_PORT_PROFILE]) client_sock, address = server_sock.accept() print ("Conexion satisfactoria",address) ser = serial.Serial('COM7', 9600) try: while(True): sensor = ser.readline() data = client_sock.recv(1024) if sensor=="1": room = 1 client_sock.send('1') sendEmail(room) if sensor=="2": room = 2 client_sock.send('2') sendEmail(room) if sensor=="2": room = 3 client_sock.send('3') sendEmail(room) if sensor=="0": break print ("#conexion terminada") except: ser.close()
def connect(self, _localMACAddress): self.localMACAddress = _localMACAddress try: # Creamos un nuevo socket Bluetooth que usa el protocolo de transporte especificado self.serverSocketRFCOMM = bluetooth.BluetoothSocket(bluetooth.RFCOMM) # Enlazamos al adaptador local algun puerto disponible self.serverSocketRFCOMM.bind((self.localMACAddress, bluetooth.PORT_ANY)) # Especificamos el numero de conexiones permitidas (todavia sin aceptar) antes de rechazar las nuevas entrantes self.serverSocketRFCOMM.listen(CONNECTIONS) # Especificamos el tiempo de espera de conexiones (funcion 'accept') self.serverSocketRFCOMM.settimeout(TIMEOUT) # Utilizamos SDP para anunciar nuestro servicio bluetooth.advertise_service(self.serverSocketRFCOMM, self.localServiceName, service_id = self.localUUID, service_classes = [self.localUUID, bluetooth.SERIAL_PORT_CLASS], profiles = [bluetooth.SERIAL_PORT_PROFILE]) # Almacenamos el puerto asignado por el 'bind' self.localPortRFCOMM = self.serverSocketRFCOMM.getsockname()[1] ####################################################################### self.bluetoothTransmitter = bluetoothTransmitter.BluetoothTransmitter() ####################################################################### self.successfulConnection = True return True except bluetooth._bluetooth.error as bluetoothError: logger.write('ERROR', '[BLUETOOTH] Código de error %s - %s.' % (bluetoothError[0], bluetoothError[1])) self.successfulConnection = False return False
def simpleSPPServer(name, clientHandler): """Main loop for a simple single-connection Serial Port Profile server. This advertises an SPP service, and waits for clients to connect. When a client connects, clientHandler(socket) is invoked. Exceptions are logged, and cause the connection to terminate. """ socket = bluetooth.BluetoothSocket(bluetooth.RFCOMM) socket.bind(('', bluetooth.PORT_ANY)) socket.listen(1) bluetooth.advertise_service(socket, name, service_classes = [bluetooth.SERIAL_PORT_CLASS], profiles = [bluetooth.SERIAL_PORT_PROFILE]) while True: logger.log("Listening for clients on RFCOMM channel %d" % socket.getsockname()[1]) clientSocket, clientInfo = socket.accept() logger.log("Client %s connected" % clientInfo[0]) try: clientHandler(clientSocket) except KeyboardInterrupt: pass except Exception, e: logger.log("*** Unhandled exception\n%s" % traceback.format_exc().strip()) clientSocket.close()
def listen_for_rfcomm_connection(self): """ Starts bluetooth interfaces """ # prepare bluetooth server self.server_sock = BluetoothSocket(RFCOMM) self.server_sock.bind(("", PORT_ANY)) self.server_sock.listen(1) self.rfcomm_channel = self.server_sock.getsockname()[1] # start listening for incoming connections try: advertise_service( sock=self.server_sock, name=self.service_name, service_id=self.service_uuid, service_classes=[self.service_uuid, SERIAL_PORT_CLASS], profiles=[SERIAL_PORT_PROFILE] ) except: LOGGER.exception("[ERROR] failed to advertise service") return LOGGER.info('waiting for connection on RFCOMM channel %d', self.rfcomm_channel) # accept received connection self.client_sock, self.client_info = self.server_sock.accept() self.state = self.__states__.STATE_CONNECTED LOGGER.info('accepted connection from %r', self.client_info) # start listening for data self.consume_bus()
def main_server(): server_sock=bluetooth.BluetoothSocket(bluetooth.RFCOMM) #port = bluetooth.get_available_port(bluetooth.RFCOMM) server_sock.bind(("",0)) server_sock.listen(1) port = server_sock.getsockname()[1] print "listening on port %d" % port uuid = "00001101-0000-1000-8000-00805F9B34FB" bluetooth.advertise_service( server_sock, "Copy-Sync-Paste", service_id=uuid ) client_sock,address = server_sock.accept() print "Accepted connection from ",address clip_text = "" while True: try: text = client_sock.recv(1024) if len(text)!=0: clip_text=clip_text + text else: break except Exception as e: pass break print clip_text bluetooth.stop_advertising(server_sock) server_sock.close() client_sock.close() setClipBoardContents(clip_text) print getClipBoardContents() print "Done."
def runServer(): serverSocket=bluetooth.BluetoothSocket(bluetooth.RFCOMM) port=bluetooth.PORT_ANY serverSocket.bind(("",port)) print "Listening for connections on port: ", port serverSocket.listen(1) port=serverSocket.getsockname()[1] #the missing piece bluetooth.advertise_service( serverSocket, "SampleServer", service_id = uuid, service_classes = [ uuid, bluetooth.SERIAL_PORT_CLASS ], profiles = [ bluetooth.SERIAL_PORT_PROFILE ] ) inputSocket, address=serverSocket.accept() print "Got connection with" , address while 1: data = inputSocket.recv(1024) print "Received: %s" % data if (data == "0"): #if '0' is sent from the Android App, turn OFF the LED print "0 is pressed" if (data == "1"): #if '1' is sent from the Android App, turn OFF the LED print "1 is pressed" if (data == "q"): print "Quit" break inputSocket.close() serverSocket.close()
def bind(self): AuthenticatedTransport.bind(self) self._adapter.SetProperty('Discoverable', self._address is None, signature='sv') self._serverSocket = bluetooth.BluetoothSocket(bluetooth.RFCOMM) self._serverSocket.bind(('', bluetooth.PORT_ANY)) self._serverSocket.listen(self['socketConnectionBacklog']) bluetooth.advertise_service(self._serverSocket, 'kozo', service_id=self._uuid, service_classes=[self._uuid, bluetooth.SERIAL_PORT_CLASS], profiles=[bluetooth.SERIAL_PORT_PROFILE]) infoTransport(self, 'Bound on port', self._serverSocket.getsockname()[1], 'with UUID', self._uuid)
def __init__(self, storage_queue): global server_port, server_uuid, android_queue android_queue = storage_queue self.server_sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM) self.server_sock.bind(("", server_port)) self.server_sock.listen(1) bluetooth.advertise_service(self.server_sock, "MDP Group 7 RPi", server_uuid) print "[BluetoothAPI] Accepting bluetooth connection on Port %s..." % server_port
def bt_advertise(name, uuid, socket): if BLUEZ: bluetooth.advertise_service( socket, name, service_id = uuid, service_classes = [ uuid, bluetooth.SERIAL_PORT_CLASS ], profiles = [ bluetooth.SERIAL_PORT_PROFILE ] ) else: lightblue.advertise(name, socket, lightblue.RFCOMM)
def __switch_connectable(self): if (self.connectable == 'yes' or self.connectable == 'filtered') and not self.server_io_watch: self.server_io_watch = gobject.io_add_watch(self.server_sock, gobject.IO_IN, self.handle_connection) bluetooth.advertise_service(self.server_sock, self.name, self.serverid) elif self.connectable == 'no' and not self.connected: bluetooth.stop_advertising(self.server_sock) gobject.source_remove(self.server_io_watch) self.server_io_watch = None self.emit('connectable_event', self.connectable)
def run(self): if self.jr.communication_style == "WIFI": while 1: success, d = self.jr.camera_driving_socket.receiveData() if success: self.updateValues(success,d[0].split('/')) else: self.updateValues(success, None) else: bluetooth.advertise_service(self.jr.camera_driving_socket, "jr_camera_driving_service", service_id=self.jr.CAMERA_DRIVING_SERVICE_UUID, service_classes=[self.jr.CAMERA_DRIVING_SERVICE_UUID, bluetooth.SERIAL_PORT_CLASS], profiles=[bluetooth.SERIAL_PORT_PROFILE], # protocols = [ OBEX_UUID ] ) try: [addr, port] = self.jr.camera_driving_socket.getsockname() print "Advertising CAMERA DRIVING service on address" + str(addr) + " and port: " + str(port) self.jr.camera_driving_socket_client_sock, self.jr.camera_driving_socket_client_sock_info = self.jr.camera_driving_socket.accept() print "Connection established for CAMERA DRIVING service, acceptd from", self.jr.camera_driving_socket_client_sock_info except IOError: print "IOError in driving accepting connection" timeout = 0.05 self.jr.camera_driving_socket_client_sock.settimeout(timeout) while True: try: d = self.jr.camera_driving_socket_client_sock.recv(1024) self.jr.camera_driving_socket_client_sock.send("received") if len(d) > 0: self.updateValues(True, d.split('/')) else: print "wrong command sent to DRIVING service" except IOError, e: if str(e) == "timed out": self.updateValues(False, None) else: print "CAMERA DRIVING connection lost with: ", self.jr.driving_socket_client_sock_info print "Error number:", e.errno print "Error:", e connected = False while not connected: try: self.jr.camera_driving_socket_client_sock, self.jr.camera_driving_socket_client_info = self.jr.camera_driving_socket.accept() self.jr.camera_driving_socket_client_sock.settimeout(timeout) print "Connection established for DRIVING service, acceptd from", self.jr.camera_driving_socket_client_info connected = True except IOError: print "IOError in driving accepting connection"
def start_rfcomm_server(event): """Starts a threaded RFCOMM server, which keeps listening to incoming data.""" global client_sock, self_sock, abort_connection, connection_active if sys.platform == 'linux': # saves users the horrible pain of making their device discoverable code = subprocess.call(['sudo', 'hciconfig', 'hci0', 'piscan']) if not code: print("enabled bluetooth") else: print("failed to enable bluetooth") connection_active = True self_sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM) port = 0 data_size = 1024 self_sock.bind(("", port)) self_sock.listen(1) uuid = "bcfa2015-0e37-429b-8907-5b434f9b9093" bt_service_name = "PiWatch Android Connection Service" bluetooth.advertise_service(self_sock, bt_service_name, service_id=uuid, service_classes=[uuid, bluetooth.SERIAL_PORT_CLASS], profiles=[bluetooth.SERIAL_PORT_PROFILE]) print("Advertising bt service: ", bt_service_name) try: global client_address client_sock, client_address = self_sock.accept() except OSError: if abort_connection: print('bt connection aborted') service.eventqueue.add(Event('bt connection aborted')) else: print('bt connection failed') service.eventqueue.add(Event('bt connection failed')) bt_clean_up() except: print('bt connection failed') service.eventqueue.add(Event('bt connection failed')) bt_clean_up() else: print("Accepted connection from ", client_address[0]) service.eventqueue.add(Event('bt connection active', data=bluetooth.lookup_name(client_address[0]))) try: client_sock.send("Hey There!") while True: print(abort_connection) data = client_sock.recv(data_size) if data: service.eventqueue.add(Event('bt data received', data=data)) print("Received bluetooth data: " + str(data)) except: pass finally: bt_clean_up() service.eventqueue.add(Event('bt connection aborted'))
def make_socket(): s = bluetooth.BluetoothSocket(bluetooth.RFCOMM) s.bind(("", bluetooth.PORT_ANY)) s.listen(1) bluetooth.advertise_service(s, SERVICE_NAME, '', service_classes=[bluetooth.SERIAL_PORT_CLASS], profiles=[bluetooth.SERIAL_PORT_PROFILE]) return s
def __init__(self): threading.Thread.__init__(self) self.running = True self.server_sock = bt.BluetoothSocket(bt.RFCOMM) self.server_sock.bind(('', bt.PORT_ANY)) self.server_sock.listen(1) self.sock = None bt.advertise_service(self.server_sock, "RemoteAlarm", server_uuid)
def server(): server_sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM) server_sock.bind(("", 0)) server_sock.listen(1) print "Listening on port 0" bluetooth.advertise_service(server_sock, "DroidPad Service", UUID) client_sock,address = server_sock.accept() print "Accepted connection from ", address return client_sock
def start(self): try: self.server_socket = bluetooth.BluetoothSocket( bluetooth.RFCOMM ) self.server_socket.bind(("", bluetooth.PORT_ANY)) self.server_socket.listen(1) self.server_socket.settimeout(5) bluetooth.advertise_service(self.server_socket, "pyTwinkle", service_classes = [ bluetooth.SERIAL_PORT_CLASS ], profiles = [ bluetooth.SERIAL_PORT_PROFILE ] ) super(self.__class__, self).start() except: print >>sys.stderr, "Could not start a bluetooth server." sys.stdout.flush()
def __init__(self): self._server_socket = s = bt.BluetoothSocket(bt.RFCOMM) s.bind(("",bt.PORT_ANY)) s.listen(5) self._port = s.getsockname()[1] D("Advertising service %s" % SERVICE) bt.advertise_service(s,SERVICE, service_id = UUID, service_classes = [UUID, bt.SERIAL_PORT_CLASS], profiles = [bt.SERIAL_PORT_PROFILE] )
def start(self): assert self._socket is None and self._incomingId is None self._socket = bluetooth.BluetoothSocket(self._protocol["transport"]) self._socket.settimeout(self._timeout) self._socket.bind(("", bluetooth.PORT_ANY)) self._socket.listen(1) self._incomingId = gobject.io_add_watch( self._socket, gobject.IO_IN, self._on_incoming ) bluetooth.advertise_service(self._socket, self._protocol["name"], self._protocol["uuid"]) self.emit("start_listening")
def waitRequisition(self): """Método que aguarda a requisição do cliente bluetooth """ self.server_sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM) self.server_sock.bind(("", 3)) self.server_sock.listen(1) bluetooth.advertise_service(self.server_sock, self.name, self.uuid) print ("Waiting for connection on RFCOMM") self.client_sock, self.client_info = self.server_sock.accept() print (self.client_info, ": connection accepted")
def handle_connection(self, serversocket, condition): """ Handles incoming connections. The handler disconnects from the mainloop by returning false. The function checks whether we are in connectable or filtered mode. If we are in connectable mode or the remote device is allowed to connect, when in filter mode, a client connection is established, the corresponding signal is fired, the disconnect handler (L{handle_disconnection}) coupled to the serversocket and the client handler coupled to the client socket (L{handle_incoming_data}). When we are in not-connectable mode or the device is not allowed to connect in filtered mode, we close the client socket. If we are in filtered mode we reattach this watch to the mainloop and advertise our socket. @type self: BTServer @param self: The BTServer object responsible for handling the connection @type serversocket: bluetooth.BluetoothSocket @param serversocket: A bluetooth socket responsible for handling incoming connections @type condition: integer (gobject.Enum) @param condition: The condition of the serversocket which caused the handler to be called should always be gobject.IO_IN (=1) @rtype: bool @return: always False, as we only allow one concurrent connection """ bluetooth.stop_advertising(self.server_sock) self.client_sock,client_address = self.server_sock.accept() logging.debug("Serversocket: " + str(self.server_sock.getsockname())) if ( self._check_pairing(client_address) and (self.connectable == 'yes' or (self.connectable == 'filtered' and client_address[0] in self.filter))): self.connected = client_address self.emit("connect", client_address[0], client_address[1]) self.bluetooth_connection = BTConnection(self.client_sock) self.bluetooth_keycode = self.bluetooth_connection.connect( "keycode", lambda btc, mp, kc: self.emit("keycode", mp, kc)) self.server_io_watch = gobject.io_add_watch(self.client_sock, gobject.IO_HUP, self.handle_disconnection) else: logging.debug("BTServer: Closing remote connection") self.client_sock.close() self.client_sock = None if self.connectable == 'filtered': self.server_io_watch = gobject.io_add_watch(self.server_sock, gobject.IO_IN, self.handle_connection) bluetooth.advertise_service(self.server_sock, self.name, self.serverid) return False
lcd = Adafruit_CharLCD() lcd.begin(16, 1) buzzer = Buzzer(17) GPIO.setmode(GPIO.BCM) GPIO.setup(18, GPIO.IN, pull_up_down=GPIO.PUD_UP) server_socket = bluetooth.BluetoothSocket(bluetooth.RFCOMM) port = 1 server_socket.bind(("", port)) server_socket.listen(1) uuid = "94f39d29-7d6d-497d-973b-fba39e49d4ee" bluetooth.advertise_service( server_socket, "samepleServer", service_id=uuid, service_classes=[uuid, bluetooth.SERIAL_PORT_CLASS], profiles=[bluetooth.SERIAL_PORT_PROFILE], ) realTime_Hour = "" realTime_Minute = "" str_hour = "" str_minute = "" alarmFlag = 1 getCurrentTime.TaskCurrentTime() def alarm_On(): print('Alarm on')
#!/usr/bin/env python3 """PyBluez ble example beacon.py Advertises a bluethooth low energy beacon for 15 seconds. """ import time import bluetooth sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM) bluetooth.advertise_service(sock, 'Location Hub', description='garage') while True: pass
import bluetooth import os server_sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM) server_sock.bind(("", bluetooth.PORT_ANY)) server_sock.listen(1) port = server_sock.getsockname()[1] uuid = "93fd0c34-5cf0-4c07-8b12-06fcc82e17f0" bluetooth.advertise_service(server_sock, "Lno", service_id=uuid) print("Waiting for connection on RFCOMM channel", port) client_sock, client_info = server_sock.accept() print("Accepted connection from", client_info) try: while True: data = client_sock.recv(1024) if not data: print("not data") break if data == b'record': os.system("echo Record start") elif data == b'stop': os.system("echo Record stop") print(data) except OSError:
import configparser as ConfigParser import pdb import wifiScript as w import dioScript as d server_sock=bluetooth.BluetoothSocket( bluetooth.RFCOMM ) port = 0 server_sock.bind(("",port)) server_sock.listen(1) print("listening on port %d" % port) uuid = "00001101-0000-1000-8000-00805F9B34FB" bluetooth.advertise_service( server_sock, "Inspirado Service", uuid ) app_key = "1mqt8n70964mn8n" app_secret = "3p9t99oz4i9cgg3" """ Network Objects: ID [int] SSID [string] SecurityType [string] ServiceKey [string] <- specific to conmanctl ConnectionStatus [string] """ def handleCommand(cmd, parameters = ""): # Switch for handling various commands with associated parameters
while (buzz > 0): if buzz > 0: print("xd") GPIO.setmode(GPIO.BCM) GPIO.output(buzzerPin, GPIO.HIGH) sleep(length) GPIO.output(buzzerPin, GPIO.LOW) sleep(length) buzz = buzz - 1 else: break #enabledAlert(0.1, 3) bluetooth.advertise_service(server_socket, "SampleServer", service_classes=[bluetooth.SERIAL_PORT_CLASS], profiles=[bluetooth.SERIAL_PORT_PROFILE]) print("Bluetooth device Is connected!2") client_socket, address = server_socket.accept() print("Bluetooth device Is connected!3") #server_socket.send('\x1a') print("Bluetooth device Is connected!4") #enabledAlert(0.2, 2) def return_data(): try: while True: data = client_socket.recv(1024) if not data:
def __init__(self, hardware, parameters, parent): QtCore.QThread.__init__(self, parent) halModule.HalModule.__init__(self) self.click_step = 1.0 self.click_timer = QtCore.QTimer(self) self.click_x = 0.0 self.click_y = 0.0 self.client_sock = False self.connected = False self.default_image = QtGui.QImage("bt_image.png") self.drag_gain = 1.0 self.drag_multiplier = 100.0 self.drag_x = 0.0 self.drag_y = 0.0 self.filming = False self.image_is_new = True self.images_sent = 0 self.is_down = False self.is_drag = False self.lock_jump_size = 0.025 self.messages = [] self.mutex = QtCore.QMutex() self.send_pictures = hardware.send_pictures self.show_camera = True self.start_time = 0 self.which_camera = "camera1" # Set current image to default. self.current_image = self.default_image # Setup bluetooth socket. have_bluetooth = True try: self.server_sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM) self.server_sock.bind(("", bluetooth.PORT_ANY)) self.server_sock.listen(1) port = self.server_sock.getsockname()[1] hdebug.logText( "Bluetooth: Listening on RFCOMM channel {0:d}".format(port)) uuid = "3e1f9ea8-9c11-11e3-b248-425861b86ab6" bluetooth.advertise_service( self.server_sock, "halServer", service_id=uuid, service_classes=[uuid, bluetooth.SERIAL_PORT_CLASS], profiles=[bluetooth.SERIAL_PORT_PROFILE], ) except: print traceback.format_exc() hdebug.logText("Failed to start Bluetooth") have_bluetooth = False if have_bluetooth: # Setup timer. self.click_timer.setInterval(200) self.click_timer.timeout.connect(self.handleClickTimer) self.click_timer.setSingleShot(True) # Connect signals. self.newData.connect(self.handleNewData) self.start(QtCore.QThread.NormalPriority)
def main(): #ctx = SSL.Context(SSL.TLSv1_METHOD) #server_sock = SSL.Connection(ctx, bluetooth.BluetoothSocket(bluetooth.RFCOMM)) #server_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) server_sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM) tanCounter = 0 aid = "2" port = 19 server_sock.bind(("", port)) server_sock.listen(5) i = 0 j = 0 k = 0 print "Listening to port %d" % port uuid = "8ce255c0-200a-11e0-ac64-0800200c9a66" bluetooth.advertise_service(server_sock, "Kaffeeautomat", uuid) while 1: client_sock, address = server_sock.accept() print "Accepted connection from ", address while 1: try: data = client_sock.recv(1024) print "received [%s]" % data if data.startswith("ACCEPT"): check[i] = data.split("T")[1] i += 1 client_sock.send("OKSTOP") elif data.startswith("BUY"): print data tmp = data.split(":") print tmp[1] + "; " + tmp[2] j = i while j >= 0: print j if check[j] == tmp[1]: print "IN" if tan[j] == tmp[2]: check[j] = "done" tan[j] = "done" GPIO.output(23, GPIO.HIGH) time.sleep(5) GPIO.output(23, GPIO.LOW) print "Threw out" client_sock.send("OKSTOP") j = 0 break else: print "NOHIT" j -= 1 if j == -1: client_sock.send("ERRORSTOP") j = 0 except: print "Connection lost" break client_sock.close() server_sock.close()
import bluetooth server_sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM) #port = bluetooth.get_available_port( bluetooth.RFCOMM ) port = 1 server_sock.bind(("", port)) server_sock.listen(1) print("listening on port %d" % port) uuid = "1e0ca4ea-299d-4335-93eb-27fcfe7fa848" bluetooth.advertise_service(server_sock, "FooBar Service", uuid) client_sock, address = server_sock.accept() print("Accepted connection from ", address) data = client_sock.recv(1024) print("received [%s]" % data) client_sock.close() server_sock.close()
def start(self): ''' Serves a socket on the default port, listening for clients. Upon client connection, runs a loop to that receives period-delimited messages from the client and calls the sub-class's handleMessage(self, message) method. Sub-class can call send(self, message) to send a message back to the client. Begins listening again after client disconnects. ''' # Make device visible os.system("hciconfig hci0 piscan") # Create a new server socket using RFCOMM protocol server_sock = bt.BluetoothSocket(bt.RFCOMM) # Bind to any port server_sock.bind(("", bt.PORT_ANY)) # #server_sock.find(("", 1))# # Start listening server_sock.listen(1) # Get the port the server socket is listening port = server_sock.getsockname()[1] # Start advertising the service bt.advertise_service(server_sock, "RaspiBtSrv", service_id=self.uuid, service_classes=[self.uuid, bt.SERIAL_PORT_CLASS], profiles=[bt.SERIAL_PORT_PROFILE]) # Outer loop: listen for connections from client while True: print("Waiting for connection on RFCOMM channel %d" % port) try: # This will block until we get a new connection self.client_sock, client_info = server_sock.accept() print("Accepted connection from " + str(client_info)) # Track strings delimited by '.' s = '' try: on = open(pathON, 'r') neededContents = on.read() nC = neededContents.split('|')[:-1] op = open(pathOP, 'r') presentContents = op.read() pC = presentContents.split('|')[:-1] bl = open(pathBL, 'r') bp = bl.read() # bp - battery percentage print("Sending List of Objects missing") for need in nC: if need not in pC: print(need) self.send("OM:" + need) print("Sending List of Objects present ") for present in pC: print(present) self.send("OP:" + present) print("Sending battery level of Pi") print(bp) self.send("BL:" + bp) except IOError: print("Trouble reading file. Trying again after 5 seconds") time.sleep(5) #while True: #self.send("Object Missing"); #self.send("U|0|1") #c = self.client_sock.recv(1).decode('utf-8') #if c == '.' and len(s) > 0: # self.handleMessage(s) #self.send(s) #print(s) # self.handleMessage(s) # s = '' #else: # s += c except IOError: pass except KeyboardInterrupt: if self.client_sock is not None: self.client_sock.close() server_sock.close() print("Server going down") break
def advertise_service(self): bluetooth.advertise_service(self.server_sock, self.name, self.uuid)
#GPIO.setmode(GPIO.BOARD) #inputPin = 7 #GPIO.setup(inputPin, GPIO.IN) ## Setup Socket server_sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM) server_sock.bind(("", bluetooth.PORT_ANY)) server_sock.listen(1) port = server_sock.getsockname()[1] ## How to read and write through bluetooth uuid = "94f39d29-7d6d-437d-973b-fba39e49d4ee" bluetooth.advertise_service(server_sock, "SampleServer", service_id=uuid, service_classes=[uuid, bluetooth.SERIAL_PORT_CLASS], profiles=[bluetooth.SERIAL_PORT_PROFILE], #protocols=[bluetooth.OBEX_UUID] ) print("Waiting for connection on RFCOMM channel", port) client_sock, client_info = server_sock.accept() print("Accepted connection from", client_info) try: while True: sendMessage = "bye jake" print(sendMessage) client_sock.send(sendMessage) data = client_sock.recv(1024) if not data:
def __init__(self, config=None, **kwds): super().__init__(**kwds) self.cfv_fn = None self.click_step = 1.0 self.click_timer = QtCore.QTimer(self) self.click_x = 0.0 self.click_y = 0.0 self.client_sock = False self.connected = False self.default_image = QtGui.QImage("bt_image.png") self.drag_gain = 1.0 self.drag_x = 0.0 self.drag_y = 0.0 self.filming = False self.image_is_new = True self.images_sent = 0 self.is_down = False self.is_drag = False self.messages = [] self.mutex = QtCore.QMutex() self.offset_min = None self.offset_max = None self.parameters = params.StormXMLObject() self.qpd_fn = None self.running = False self.send_pictures = config.get("send_pictures") self.show_camera = True self.stage_fn = None self.start_time = 0 self.sum_min = None self.sum_max = None self.parameters.add( params.ParameterRangeFloat(description="Drag multiplier", name="d_mult", value=100.0, min_value=0.1, max_value=1000.0)) self.parameters.add( params.ParameterRangeFloat(description="Z step size in um", name="z_step", value=0.1, min_value=0.0, max_value=5.0)) # Set current image to default. self.current_image = self.default_image # Setup bluetooth socket. have_bluetooth = True try: self.server_sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM) self.server_sock.bind(("", bluetooth.PORT_ANY)) self.server_sock.listen(1) port = self.server_sock.getsockname()[1] print("Bluetooth: Listening on RFCOMM channel {0:d}".format(port)) uuid = "3e1f9ea8-9c11-11e3-b248-425861b86ab6" bluetooth.advertise_service( self.server_sock, "halServer", service_id=uuid, service_classes=[uuid, bluetooth.SERIAL_PORT_CLASS], profiles=[bluetooth.SERIAL_PORT_PROFILE]) except bluetooth.btcommon.BluetoothError: print(traceback.format_exc()) print("Failed to start Bluetooth") have_bluetooth = False if have_bluetooth: # Setup timer. self.click_timer.setInterval(200) self.click_timer.timeout.connect(self.handleClickTimer) self.click_timer.setSingleShot(True) # Connect signals. self.newMessage.connect(self.handleNewMessage) self.start(QtCore.QThread.NormalPriority)
localhost - locally advertised SDP ''' import bluetooth from time import time server_sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM) # Use SDP port = 0 server_sock.bind(("",port)) server_sock.listen(1) # Not works totally, just use uuid uuid = "1e0ca4ea-299d-4335-93eb-27fcfe7fa848" bluetooth.advertise_service(server_sock, "Foobar Service",\ service_classes=[bluetooth.SERIAL_PORT_CLASS],\ profiles=[bluetooth.SERIAL_PORT_PROFILE]) while True: client_sock, address = server_sock.accept() print("Accepted connection from ", address) try: data = client_sock.recv(1024) print("Received [%s]" % data) except Exception as e: print("[{}] {}".format(time(),repr(e))) finally: client_sock.close() server_sock.close()
########################################################################################################### ## main function/ code if __name__ == "__main__": print("Starting server...") #create bluetooth socket and acept connection from master server = bluetooth.BluetoothSocket(bluetooth.RFCOMM) server.bind(("", BTPortNo)) server.listen(1) strin = "Chip device" myinfo = sensor_top.detectall() bluetooth.advertise_service(server,strin,service_classes = [bluetooth.SERIAL_PORT_CLASS],\ profiles=[bluetooth.SERIAL_PORT_PROFILE]\ , description = str(myinfo)) try: print("Waiting for connection from master [RFCOMM port=%d]" % BTPortNo) while (1): try: client, client_info = server.accept() print("Connected to", client_info) thread_name = '_' + client_info[0] thread.start_new_thread(new_client, (thread_name, 0, client, client_info)) #handle exceptions/ctrl + c except KeyboardInterrupt: print("Shutting down...") client.close()
# Scrive un file. out_file = open(fileout, "w") out_file.write(text) out_file.close() server_sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM) port = 3 server_sock.bind(("", port)) server_sock.listen(1) myUuid = "94f39d29-7d6d-437d-973b-fba39e49d4ef" bluetooth.advertise_service(server_sock, "SampleServerL2CAP", service_id=myUuid, service_classes=[myUuid]) while True: try: client_sock, address = server_sock.accept() print("Accepted connection from ", address) strInput = '' data = '' try: data = client_sock.recv(1) strInput = data while (data != '&'): data = client_sock.recv(1) if (data != '&'):
def runServer(): global x global servoPin1 global servoPin2 global servoPin3 global servoPin4 global servoPin5 GPIO.setwarnings(False) GPIO.setmode(GPIO.BCM) GPIO.setup(servoPin1, GPIO.OUT) GPIO.setup(servoPin2, GPIO.OUT) GPIO.setup(servoPin3, GPIO.OUT) GPIO.setup(servoPin4, GPIO.OUT) GPIO.setup(servoPin5, GPIO.OUT) pwm1 = GPIO.PWM(servoPin1, 50) pwm1.start(5) pwm2 = GPIO.PWM(servoPin2, 50) pwm2.start(5) pwm3 = GPIO.PWM(servoPin3, 50) pwm3.start(5) pwm4 = GPIO.PWM(servoPin4, 50) pwm4.start(5) pwm5 = GPIO.PWM(servoPin5, 50) pwm5.start(5) serverSocket = bluetooth.BluetoothSocket(bluetooth.RFCOMM) port = bluetooth.PORT_ANY serverSocket.bind(("", port)) print "Servo Server" print "Listening for connections on port: ", port while 1: # wait for a message to be sent serverSocket.listen(0) port = serverSocket.getsockname()[1] bluetooth.advertise_service(serverSocket, "BluetoofServer", service_id=uuid, service_classes=[uuid, bluetooth.SERIAL_PORT_CLASS], profiles=[bluetooth.SERIAL_PORT_PROFILE] ) inputSocket, address = serverSocket.accept() print "Got connection with ", address while 1: try: data = inputSocket.recv(1024) data = data.split("}")[0] + "}" data = dict(ast.literal_eval(data)) servo = data["servo"]; pos = data["position"] print(str(servo) + " : " + str(pos)) if (servo == "s1"): targetPwm = pwm1 if (servo == "s2"): targetPwm = pwm2 if (servo == "s3"): targetPwm = pwm3 if (servo == "s4"): targetPwm = pwm4 if (servo == "s5"): targetPwm = pwm5 targetPwm.ChangeDutyCycle(convertToDegrees(pos)) except bluetooth.btcommon.BluetoothError: print("Exception thrown: quitting...") break
def main(): # Defining Dynamixel IDs (Input for control) # Bluetooth Functions server_sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM) server_sock.bind(("", bluetooth.PORT_ANY)) server_sock.listen(1) port = server_sock.getsockname()[1] uuid = "94f39d29-7d6d-437d-973b-fba39e49d4ee" bluetooth.advertise_service( server_sock, "SampleServer", service_id=uuid, service_classes=[uuid, bluetooth.SERIAL_PORT_CLASS], profiles=[bluetooth.SERIAL_PORT_PROFILE], # protocols=[bluetooth.OBEX_UUID] ) print("Waiting for connection on RFCOMM channel", port) client_sock, client_info = server_sock.accept() print("Accepted connection from", client_info) # After connected to device receive data and print data # we need to integrate the app we will be developing to the data here # We might need another way to bluetooth connect, not sure how the mit app inventor bluetooth connection work, but should work # Refer to https://github.com/pybluez/pybluez for more examples and more functions that we can use try: while True: data = client_sock.recv(1024) if not data: break print(data) # Do we want to implement check for busy arm and queue system for order drink? # We probably can do that by implementing a variable state which stores the number of drinks in queue and run a check # For non busy easy. For queue, arm would store the order and return to app queue number etc. data = data.decode('utf-8').split("\"") # Formatting Output # Number of drinks n = int((len(data) - 1) / 6) print("Number of drinks", n) # Formatting Data for use arr = [] for x in range(1, len(data), 2): arr1 = [data[x]] arr = arr + arr1 print(arr ) # Array of drinks e.g. [coffee,cold,0%,coffee,cold,0%] for x in range(1, n + 1): print("Serving Drink ", x, arr[0 + 3 * (x - 1)]) # Added timer delay for testing in app, please remove after added sequence for moving arm drink = arr[3 * (x - 1)] temp = arr[3 * (x - 1) + 1] sugar = arr[3 * (x - 1) + 2] print("Drink details:", drink, temp, sugar) print("Moving arm to ", drink, "dispenser") time.sleep(5) print("Dispensing Drink", x, drink) client_sock.send( ("Dispensing Drink " + str(x) + ":" + drink).encode()) time.sleep(5) print("Delivering Drink", x, drink) client_sock.send( ("Delivering Drink " + str(x) + ":" + drink).encode()) time.sleep(5) print("Delivered") client_sock.send(("Drink " + str(x) + " delivered").encode()) except OSError: pass print("Disconnected.") client_sock.close() server_sock.close() print("All done.")
def launch_hub_bluetooth_server(config_file_path): ''' Launches the Tremium Hub bluetooth server which the Tremium Nodes connect to. Parameters ---------- config_file_path (str) : path to the hub configuration file ''' # loading Tremium Hub configurations config_manager = HubConfigurationManager(config_file_path) log_file_path = os.path.join( config_manager.config_data["hub-file-transfer-dir"], config_manager.config_data["bluetooth-server-log-name"]) # setting up logging logger = logging.getLogger() logger.setLevel(logging.INFO) log_handler = logging.handlers.WatchedFileHandler(log_file_path) log_handler.setFormatter( logging.Formatter('%(name)s - %(levelname)s - %(message)s')) logger.addHandler(log_handler) # defining container for connection handler handles connection_handlers_h = [] try: # creating socket to listen for new connections listener_s = BluetoothSocket() listener_s.bind( (config_manager.config_data["bluetooth-adapter-mac-server"], config_manager.config_data["bluetooth-port"])) listener_s.listen(1) # advertising the listenning connection advertise_service(listener_s, config_manager.config_data["hub-id"]) bind_address = listener_s.getsockname() time_str = datetime.datetime.fromtimestamp( time.time()).strftime('%Y-%m-%d_%H-%M-%S') logging.info( "{0} - Hub Bluetooth server listening on address : {1}".format( time_str, bind_address)) except Exception as e: time_str = datetime.datetime.fromtimestamp( time.time()).strftime('%Y-%m-%d_%H-%M-%S') logging.error( "{0} - Hub Bluetooth server failed to create listener socket : {1}" .format(time_str, e)) raise while True: try: # blocking until a new connection occurs, then create connection handler client_s, remote_address = listener_s.accept() client_s.settimeout( config_manager.config_data["bluetooth-comm-timeout"]) connection_handler = HubServerConnectionHandler( config_file_path, client_s, remote_address) # launching connection handler in a seperate process process_h = Process(target=connection_handler.handle_connection, args=()) process_h.start() connection_handlers_h.append(process_h) time_str = datetime.datetime.fromtimestamp( time.time()).strftime('%Y-%m-%d_%H-%M-%S') logging.info( "{0} - Hub Bluetooth server accepted and is handling connection from remote : {1}\ ".format(time_str, remote_address)) #regular check to clear dead handles for handler_h in connection_handlers_h: if handler_h is not None: connection_handlers_h.remove(handler_h) except Exception as e: # killing all connection handler processes still running for handler_h in connection_handlers_h: if handler_h.exitcode is None: handler_h.terminate() time_str = datetime.datetime.fromtimestamp( time.time()).strftime('%Y-%m-%d_%H-%M-%S') logging.error( "{0} - Hub Bluetooth server failed to handle incoming connection : {1}" .format(time_str, e)) raise
def main(): while True: network = getCurrentNetwork() print(network) if not network: #Bluetooth setup routine via android print("In android setup") while not getCurrentNetwork(): server_sock=bluetooth.BluetoothSocket(bluetooth.RFCOMM ) server_sock.bind(("",bluetooth.PORT_ANY)) server_sock.listen(3) server_sock.settimeout(10) port = server_sock.getsockname()[1] uuid = "SECRETDUUID" bluetooth.advertise_service(server_sock, "Bluetooth-network-beacon", service_id = uuid, service_classes = [ uuid, bluetooth.SERIAL_PORT_CLASS ], profiles = [ bluetooth.SERIAL_PORT_PROFILE ], ) try: client, addr = server_sock.accept() client.settimeout(10) inc = client.recv(1024) credentials = inc.decode("UTF-8").split(" ") print(credentials) client.close() server_sock.close() connectWifi(str(credentials[0]), str(credentials[1])) print(getKnownNetworks()) except Exception as e: print(e) else: subprocess.call(["rfkill","unblock", "bluetooth"]) try: nearby_devices = bluetooth.discover_devices(lookup_names = True) for baddr,name in nearby_devices: print(name) if "ESP32" in name: port = 1 bSocket = bluetooth.BluetoothSocket(bluetooth.RFCOMM) try: print('Trying to connect') bSocket.connect((baddr, port)) inputString = returnInfo(); print(inputString) add = 16 - len(inputString) % 16 out = inputString + add * ' '; print(generateHash((out).encode("ASCII"))) bSocket.sendall(generateHash((out).encode("ASCII"))) bSocket.close() except Exception as e: bSocket.close(); print(e) except Exception as e: print(e) #subprocess.call(["rfkill","block", "bluetooth"]) time.sleep(0.5)
import json import pyowm #Python Open Weather Map import bluetooth # Python bluetooth tools server_sock=bluetooth.BluetoothSocket(bluetooth.RFCOMM ) port = 1 server_sock.bind(("",port)) server_sock.listen(1) uuid = "94f39d29-7d6d-437d-973b-fba39e49d4ee" bluetooth.advertise_service(server_sock, "nexus", uuid) client_sock,address = server_sock.accept() print "Accepted connection from ",address data = client_sock.recv(1024) print "received [%s]" % data client_sock.close() server_sock.close() try: # Register API Key with source API_key = '89cb9b3c8c3c1ee033be08ffcfd26076' owm = pyowm.OWM(API_key) # Register a location: city,state AND print location = 'Philadelphia,PA' print('Location:', location)
signal_json = Path("../common/signal.json") # signal_wav = Path("../common/signal.wav") # if not (signal_json.exists() and signal_wav.exists()) : create_signal() with open(signal_json, "r") as json_file: signal = json.loads(json_file.read())["signal"] server_sock = bt.BluetoothSocket(bt.RFCOMM) server_sock.bind(("", bt.PORT_ANY)) server_sock.listen(1) port = server_sock.getsockname()[1] uuid = "ae465fd9-2d3b-a4c6-4385-ea69b4c1e23c" bt.advertise_service( server_sock, "LocalisationServer", service_id=uuid, service_classes=[uuid, bt.SERIAL_PORT_CLASS], profiles=[bt.SERIAL_PORT_PROFILE], ) if SIMULATION: emission_offset = 500 + np.random.randint(500) record = simulate_record(emission_offset + 500, emission_offset, 0.5, signal) t1 = get_time(record, signal, emission_offset) d1 = t1 * SOUND_CELERITY response = {"accepted": False} if d1 < 1: response["accepted"] = True print("test : {}\noffset: {}\ntime: {}\ndistance: {}".format( "ACCEPTED" if response["accepted"] else "REFUSED", emission_offset,
# $Id: rfcomm-server.py 518 2007-08-10 07:20:07Z albert $ import bluetooth import bluetooth as bt server_sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM) server_sock.bind(("", bluetooth.PORT_ANY)) server_sock.listen(1) port = server_sock.getsockname()[1] uuid = "94f39d29-7d6d-437d-973b-fba39e49d4ee" bt.advertise_service( server_sock, "SampleServer", service_id = uuid, # protocols = [ OBEX_UUID ] ) print("Waiting for connection on RFCOMM channel %d" % port) client_sock, client_info = server_sock.accept() print("Accepted connection from ", client_info) try: while True: data = client_sock.recv(1024) if len(data) == 0: break print("received [%s]" % data) except IOError: pass