def close(self): """ ferme le socket """ #ferme le socket bluetooth.stop_advertising(self) self.close()
def down(self): if self._sock is not None: try: bluetooth.stop_advertising(self._sock) except bluetooth.BluetoothError, e: log.warning("failed to unregister bluetooth service (%s)" % e)
def stopadvertise(sock): if not sock._advertised: raise _lightbluecommon.BluetoothError("no service advertised") try: bluetooth.stop_advertising(sock._sock) except bluetooth.BluetoothError, e: raise _lightbluecommon.BluetoothError(str(e))
def stop(self): if self.running: print("Server shutting down") self.running = False bt.stop_advertising(self.server_sock) self.server_sock.close() print "Server shut down"
def receiveMessages(name="rovian", uu_id="d01ca4aa-c79d-43c5-94eb-a7fc4e7fa748"): # get resources port = 1 # bluetooth.get_available_port( bluetooth.RFCOMM ) server_sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM) # Setup connections server_sock.bind(("", port)) server_sock.listen(1) print("Listening on port {}".format(port)) print("Advertising as {}\n with uuid {}".format(name, uu_id)) bluetooth.advertise_service(server_sock, name, uu_id) print("Listening for connections on {}...".format(':'.join( re.findall('..', '%012x' % uuid.getnode())).encode())) sock, address = server_sock.accept() bluetooth.stop_advertising(server_sock) print("Connected!\n {}".format(address)) data = sock.recv(1024) print("received {}".format(data)) sock.close() server_sock.close()
def run(self): sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM) sock.bind(("", bluetooth.PORT_ANY)) sock.listen(1) bluetooth.advertise_service( sock, SERVICE_NAME, service_id=SERVICE_UUID, service_classes=[SERVICE_UUID, bluetooth.SERIAL_PORT_CLASS], profiles=[bluetooth.SERIAL_PORT_PROFILE]) log.debug('Advertising Bluetooth service as "%s"', SERVICE_NAME) try: while True: log.info('Waiting for connection from client...') client_sock, client_addr = sock.accept() log.info('Accepted connection from client %s.', client_addr) self.manage_connection(client_sock, client_addr) except KeyboardInterrupt: log.info('User requested termination.') finally: bluetooth.stop_advertising(sock) sock.close() log.info('Bluetooth service stopped.')
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 shutdown(self): if self.server_sock: if not self.isbinded: bluetooth.stop_advertising(self.server_sock) self.server_sock.close() if self.client_sock: self.client_sock.close()
def listenOnBluetooth(channel): """ Listen to incoming data on Bluetooth Interface Param(s): channel The Bluetooth channel to listen to """ logger = logging.getLogger() # The # of unaccepted connection before refusing new connections allowableUnacceptedConns = 1 # Receive up to this number of buffersize bytes from the socket bufferSize = 1 # Setup the Bluetooth connection server_sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM) server_sock.bind(("", channel)) server_sock.listen(allowableUnacceptedConns) # startTime = time.time() total_data = [] # Listen for incoming data, while watching for the keyboard interrupt try: # The received address is a (host, channel) tuple client_sock, address = server_sock.accept() start_time = time.time() while True: # startTime = time.time() data_1 = client_sock.recv(bufferSize) # We need a break statement because when no data is available, # recv() blocks until at least one byte is available if len(data_1) == 0: break # Append the received data to the helper variable total_data.append(data_1) except IOError: pass # Sincere apologies to all who told me passing is poor practice except KeyboardInterrupt: bluetooth.stop_advertising(server_sock) except Exception: print('No data is received, waiting...') time.sleep(5) # Log the results of the bluetooth data to the console end_time = time.time() bt_time = end_time - start_time logger.info("Bluetooth Transmission Time %f", bt_time) # Close the bluetooth connection client_sock.close() server_sock.close() return bt_time, pickle.loads(b''.join(total_data))
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 disconnect(self): if self.connected: if self.server_sock: bluetooth.stop_advertising(self.server_sock) self.server_sock.close() if self.tx: self.tx.close() self.tx_dispatcher.unregister() self.connected = False
def close(self): """ ferme le socket serveur et arrête le service attaché """ #change la variable interne self.actif = False #arrête la pub bluetooth.stop_advertising( self ) #ferme le socket bluetooth.BluetoothSocket.close(self)
def stop(self): if self._socket is None or self._incomingId is None: return gobject.source_remove(self._incomingId) self._incomingId = None bluetooth.stop_advertising(self._socket) self._socket.close() self._socket = None self.emit("stop_listening")
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
def get_connected_socket(channel): server_sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM) server_sock.bind(("", channel)) server_sock.listen(1) # server_sock.settimeout(SOCK_TIMEOUT) bluetooth.advertise_service(server_sock, "RC Droid", service_id = UUID, service_classes = [bluetooth.SERIAL_PORT_CLASS,], profiles = [bluetooth.SERIAL_PORT_PROFILE,]) sock, addr = server_sock.accept() print "Connection established:", addr bluetooth.stop_advertising(server_sock) server_sock.close() sock.settimeout(SOCK_TIMEOUT) return sock
def bluetooth_server(counter): server_sock = BluetoothSocket(RFCOMM) server_sock.bind(("", PORT_ANY)) server_sock.listen(1) while counter: uuid = "94f39d29-7d6d-437d-973b-fba39e49d4ef" advertise_service( server_sock, "SampleServer", service_id=uuid, service_classes=[uuid, SERIAL_PORT_CLASS], profiles=[SERIAL_PORT_PROFILE], # protocols = [ OBEX_UUID ] ) time.sleep(20) counter = 0 if exitFlag: bluetooth.stop_advertising(server_sock) threadName.exit()
def serve_forever(self): client_info = 'unknown' while not self._shutdown: try: client_info = 'unknown' client_sck, client_info = self.server_sck.accept() handler = self.RequestHandlerClass(self, client_sck, client_info) handler.handle() client_sck.close() except bluetooth.BluetoothError as bt_err: error_msg = str(bt_err) if not error_msg.__eq__('timed out'): log.exception( 'Exception while handling connection to |%s|', str(client_info)) except BaseException as ex: log.exception('Exception during handling of connection') bluetooth.stop_advertising(self.server_sck) self.server_sck.close()
def start_cat_alert_server(logger: logging.Logger): logger.info("Starting cat alert server") server_sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM) try: server_sock.bind(("", 0)) server_sock.listen(1) except Exception as error: logger.error("Cat alert server, error trying to bind and listen: " + str(error)) return None logger.info("Cat alert server listening for bluetooth connections") bluetooth.advertise_service(server_sock, bluetooth_const.cat_alert_service_name, bluetooth_const.cat_alert_service_uuid) while(1): try: client_sock, address = server_sock.accept() logger.info("Cat alert server accepted connection from %s", address) if address[0] == bluetooth_const.cat_station_addr: logger.info("Handling connection from %s", address) cat_info = json.loads(bluetooth_utils.recv_data(client_sock)) if cat_info["catIsHere"]: img = Image.open(io.BytesIO(bluetooth_utils.recv_data(client_sock))) img.show() print(str(cat_info["catIsHere"])) else: print(str(cat_info["catIsHere"])) else: logger.warning("Received connections from unknown source") except Exception as error: logger.error("Problem communicating with clients: " + str(error)) traceback.print_exc() break finally: client_sock.close() bluetooth.stop_advertising(server_sock) server_sock.close()
def start_weather_server(logger: logging.Logger) -> None: logger.info("Starting weather server") server_sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM) try: server_sock.bind(("", 0)) server_sock.listen(1) except Exception as error: logger.error("Error trying to bind and listen: " + str(error)) return logger.info("listening for bluetooth connections") bluetooth.advertise_service(server_sock, bluetooth_const.weather_service_name, bluetooth_const.weather_service_uuid) while (1): try: client_sock, address = server_sock.accept() logger.info("Accepted connection from %s", address) if address[0] == bluetooth_const.host_addr: logger.info("Handling connection from %s", address) resp = bluetooth_const.weather_report_prototype resp["temperature"] = 10.5 resp["pressure"] = 9.6 resp["humidity"] = 13.2 client_sock.send( json.dumps(resp)) # make sure it sends everything else: logger.warning("Received connections from unknown source") except Exception as error: logger.error("Problem communicating with clients: " + str(error)) break finally: client_sock.close() server_sock.close() bluetooth.stop_advertising(server_sock)
def listenForClients(self): self.btServerSocket = bluetooth.BluetoothSocket(bluetooth.RFCOMM) port = 29 #bluetooth.PORT_ANY res = self.btServerSocket.bind((self.serverInterfaceMac, port)) self.btServerSocket.listen(1) port = self.btServerSocket.getsockname()[1] #time.sleep(5) print 'Listening on Port: {0}'.format(port) # Advertise service bluetooth.advertise_service(self.btServerSocket, self.btName, self.btUuid) #time.sleep(2) while self.shouldRun(): try: print 'Waiting for Clients...' client_sock, client_addr = self.btServerSocket.accept() print '{0}: Connection Accepted'.format(client_addr) homePiClient = HomePiClientThread(client_sock, self) self.connectedClients.append(homePiClient) homePiClient.setDaemon(True) # Send device information to client. self.sendDeviceStatus(homePiClient) # Register client self.registerClient(homePiClient) # Start listening homePiClient.start() except KeyboardInterrupt as key: bluetooth.stop_advertising(self.btServerSocket) self.shutdown() break self.shutdown() pass
def listenForClients(self): self.btServerSocket = bluetooth.BluetoothSocket(bluetooth.RFCOMM) port = 29#bluetooth.PORT_ANY res = self.btServerSocket.bind((self.serverInterfaceMac, port)) self.btServerSocket.listen(1) port = self.btServerSocket.getsockname()[1] #time.sleep(5) print 'Listening on Port: {0}'.format(port) # Advertise service bluetooth.advertise_service(self.btServerSocket, self.btName, self.btUuid) #time.sleep(2) while self.shouldRun(): try: print 'Waiting for Clients...' client_sock, client_addr = self.btServerSocket.accept() print '{0}: Connection Accepted'.format(client_addr) homePiClient = HomePiClientThread(client_sock, self) self.connectedClients.append(homePiClient) homePiClient.setDaemon(True) # Send device information to client. self.sendDeviceStatus(homePiClient) # Register client self.registerClient(homePiClient) # Start listening homePiClient.start() except KeyboardInterrupt as key: bluetooth.stop_advertising(self.btServerSocket) self.shutdown() break self.shutdown() pass
# to ExecStart = ExecStart=/usr/lib/bluetooth/bluetoothd -C # which is supposedly some compatibility mode. Also use superPython bluetooth.advertise_service(server_sock, "piExchange", service_id=uuid, service_classes=[bluetooth.SERIAL_PORT_CLASS], profiles=[bluetooth.SERIAL_PORT_PROFILE]) # server_sock.accept() is a blocking call client_sock, address = server_sock.accept() print("Accepted connection from:", address) data = client_sock.recv(1024) print("received [%s]"%data) bluetooth.stop_advertising(server_sock) client_sock.close() server_sock.close() # import bluetooth # import serial # # ser = serial.Serial('/dev/rfcomm0') # print(ser.name) # ser.write(b'hello') # ser.close() # # host = "" # # port = 8888 # # s = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
def stop_server(): server_sock = bluetooth.BluetoothSocket(bluetooth.L2CAP) bluetooth.stop_advertising(server_sock)
services = bluetooth.find_service(address=address) for s in services: pp.pprint(s) # client_sock, client_info = interrupt_sock.accept() # print("Accepted interrupt connection from ", client_info) root = tk.Tk() root.geometry('300x200') text = tk.Text(root, background='black', foreground='white', font=('Comic Sans MS', 12)) text.pack() root.bind('<KeyPress>', onKeyPress) root.mainloop() while True: data = client_sock.recv(1024) if len(data) == 0: break print("received [%s]" % data) except IOError: pass except KeyboardInterrupt: print "Stopping..." bluetooth.stop_advertising(server_sock) sys.exit() print("disconnected") client_sock.close() server_sock.close() print("all done")
def StopAdvertising(socket: BluetoothSocket = None): stop_advertising(socket)
def bt_stop_advertising(socket): if BLUEZ: bluetooth.stop_advertising(socket) else: lightblue.stopadvertise(socket)
# 1. accept a connection client_socket, address = socket.accept() print("Received connection from", address) socket.setblocking(True) # 2. listen to commands indefinitely while True: message = client_socket.recv(128) message = message.decode('utf-8').strip() if not message: continue print("Received message:", message) if message == "END_CONNECTION": print("Ended connection with", address) break key_code = get_code(message) if key_code is None: continue press_release(key_code) finally: # close sockets after all if client_socket is not None: client_socket.close() if socket is not None: bluetooth.stop_advertising(socket) socket.close()
def stop_service(self, socket): stop_advertising(socket)
def _cleanup(self): bluetooth.stop_advertising(self.bluetooth_server_sock) self.bluetooth_server_sock.close()
def listenOnBluetooth(channelNumber): ''' Listens to incoming data on the Bluetooth Interface Param(s): (int) Port that we going to listen to Return(s) (pickle) ??? ''' allowableUnacceptedConns = 1 # The # of unaccepted connection before refusing new connections bufferSize = 1 # Receive up to this number of buffersize bytes from the socket # Setup the Bluetooth connection sense.set_pixels(LED.arrowReceive('orange', 'red')) server_sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM) server_sock.bind(("", channelNumber)) server_sock.listen(allowableUnacceptedConns) # startTime = time.time() total_data = [] # Listen for incoming data, while watching for the keyboard interrupt try: sense.set_pixels(LED.arrowReceive('orange', 'blue')) # The received address is a (host, channel) tuple client_sock, address = server_sock.accept() # startTime = time.time() while True: startTime = time.time() data_1 = client_sock.recv(bufferSize) # We need a break statement because when no data is available, # recv() blocks until at least one byte is available if len(data_1) == 0: break # Append the received data to the helper variable total_data.append(data_1) # Should we stop timing at this point? # endTime = time.time() except IOError: sense.set_pixels(LED.arrowReceive('orange', 'magenta')) # print("Ran into IOError") pass # Sincere apologies to all who told me passing is poor practice except KeyboardInterrupt: sense.set_pixels(LED.arrowReceive('orange', 'magenta')) bluetooth.stop_advertising(server_sock) # sys.exit() Why do we need an exit before we're actually done? # Log the results of the bluetooth data to the console sense.set_pixels(LED.arrowReceive('orange', 'green')) endTime = time.time() btTime = endTime - startTime print("Bluetooth Transmission Time :", btTime) # Close the bluetooth connection client_sock.close() server_sock.close() return btTime, pickle.loads(''.join(total_data))