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 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 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 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 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 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 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))
