def main(restart): #主程式 (是否重啟)
try: #避免錯誤，捕抓意外情況
bsl.server().copyleft_declaration()
sock = lightblue.socket() #產生socket物件
sock.bind(("", 1)) #綁定通道，若通道被占用，綁定通道將出錯
sock.listen(1) #聆聽RFCOMM通道1
lightblue.advertise("EchoService", sock, lightblue.RFCOMM) #開始廣播服務
if (restart): #如果重啟旗標為真
bsl.server().log(
R.msg_level.info,
R.server_msg.info.server_restart_success) #伺服器重啟成功
bsl.server().log(R.msg_level.info,
R.server_msg.info.brocasting.format(
sock.getsockname()[1])) #告知手機綁定通道
conn, addr = sock.accept() #新連線
bsl.server().log(R.msg_level.info,
R.server_msg.info.new_connection.format(addr[0]))
flag = True
while (flag):
data = conn.recv(1024).rstrip()
#print(data)
bsl.server().log(R.msg_level.info,
"{} {}".format(R.msg_direction.RX, data))
command_selector(conn, data)
except KeyboardInterrupt:
print
bsl.server().log(R.msg_level.info, R.server_msg.info.user_interrupt)
exit()
except Exception as exception: #捕抓到錯誤
exceptionString = str(exception) #錯誤原因字串
if (debugMode): #除錯模式?
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
print("{}, {}, {}, {}".format(exc_type, fname, exc_tb.tb_lineno,
exceptionString))
error_code = bsl.common().GetErrorCode(exceptionString)
#print('error_code: {}'.format(error_code))
if (error_code == '98'): #端口正在被使用中例外
bsl.server().log(R.msg_level.error,
R.server_msg.error.address_or_port_in_use)
terminated = True
elif (error_code == '104'): #使用者離線例外
bsl.server().log(R.msg_level.info,
R.server_msg.info.user_disconnect)
bsl.server().log(
R.msg_level.info,
R.server_msg.warning.server_encountered_fixable_error)
bsl.server().log(R.msg_level.info,
R.server_msg.warning.server_fixing_error)
conn.close()
sock.close()
bsl.server().log(R.msg_level.info,
R.server_msg.info.restart_server)
main(True)
elif (error_code == '13'): #權限不足例外
bsl.server().log(R.msg_level.error, R.local_msg.permission_denied)
terminated = True
elif (error_code == '111'): #連線被拒例外
bsl.server().log(R.msg_level.error, R.local_msg.connection_refused)
def advertise_service(sock, name, service_id="", service_classes=None,
profiles=None, provider="", description="", protocols=None):
if protocols is None or protocols == RFCOMM:
protocols = [lightblue.RFCOMM]
lightblue.advertise(name, sock, protocols[0], service_id)
def __init__(self, serviceName = u'FluidNexus', database = None, library="e32"):
"""Initialize the server be setting up the server socket and advertising the FluidNexus service."""
log.write("Starting Fluid Nexus Server")
# Save our database object
self.database = database
# Save our service name
self.serviceName = serviceName
self.mutex = thread.allocate_lock()
self.library = library
# Setup our server socket
if (self.library == "e32"):
self.serverSocket = socket.socket(socket.AF_BT, socket.SOCK_STREAM)
self.serverPort = socket.bt_rfcomm_get_available_server_channel(self.serverSocket)
self.serverSocket.bind(("", self.serverPort))
self.serverSocket.listen(self.numberConnections)
socket.bt_advertise_service(self.serviceName, self.serverSocket, True, socket.RFCOMM)
# Remove security protections
# @TODO@ Make sure this actually does what we want it to do!
socket.set_security(self.serverSocket, 0)
elif (self.library == "lightblue"):
self.serverSocket = lightblue.socket()
self.serverSocket.bind(("", 0))
self.serverSocket.listen(self.numberConnections)
lightblue.advertise(self.serviceName, self.serverSocket, lightblue.RFCOMM)
def run(self):
sendSkt = lightblue.socket()
sendSkt.bind(("", 0))
sendSkt.listen(1)
lightblue.advertise("SMS Gateway (Response Thread)", sendSkt,
lightblue.RFCOMM)
db = database()
conn2, addr2 = sendSkt.accept()
print "Connected to Response Server", addr2
while 1:
time.sleep(1)
db = database()
rows = db.popOutboxMsg()
for row in rows:
print "Sending Msg -> %s" % (row[0])
sms = SMS(str(row[0]), row[1], row[2], row[3], str(row[4]))
toSend = sms.toXML()
print toSend
conn2.send(toSend.replace("\n", "\\n"))
res = conn2.recv(1024)
print res
while (res != "1" and res != "2"):
res = conn2.recv(1024)
print res
db.setOutboxProcessed(str(row[0]), res)
def advertise_service(sock, name, service_id="", service_classes=None,
profiles=None, provider="", description="", protocols=None):
if protocols is None or protocols == RFCOMM:
protocols = [lightblue.RFCOMM]
lightblue.advertise(name, sock, protocols[0], service_id)
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 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 receiveFile(self, channel=0):
sock = lightblue.socket()
sock.bind(("", channel))
channelID = sock._getport()
print "receivee", sock, channelID
lightblue.advertise("LightBlue example OBEX service", sock, lightblue.OBEX)
server = lightblue.obex.OBEXServer.alloc().initWithChannel_(channelID)
d_connected = defer.Deferred()
d_disconnected = defer.Deferred()
d_putcompleted = defer.Deferred()
d_putrequested = defer.Deferred()
d_errored = defer.Deferred()
_fileobj = None
def _putrequested(session, filename, filetype, filesize):
print "req"
_fileobj = open("tmp.tmp", "wb")
filehandle = Foundation.NSFileHandle.alloc().initWithFileDescriptor_(f.fileno())
d_putrequested.callback((session, filename, filetype, filesize))
return filehandle
def _disconnected(session):
print 'disc'
d_disconnected.callback(session)
def _putcompleted(session):
print "aooa"
d_putcompleted.callback(session)
_fileobj.close()
def _errored(session, e, em):
print session, e, em
def _connected(session):
print session
d_connected.callback(session)
server.disconnected = _disconnected
server.putcompleted = _putcompleted
server.putrequested = _putrequested
server.errored = _errored
server.connected = _connected
#d_connected.addCallback(_putFile)
#d_connected.addErrback(_handleError)
#d_putcompleted.addCallback(_disconnect)
#d_putcompleted.addErrback(_handleError)
#d_disconnected.addBoth(_close)
server.start()
def lightblue_server_test():
# L2CAP server sockets not currently supported :(
s = lightblue.socket(lightblue.L2CAP)
s.bind(("", 0x1001))
s.listen(1)
lightblue.advertise("Peach", s, lightblue.L2CAP)
conn, addr = s.accept()
print("Connected by", addr)
data = conn.recv(1024)
print("Received: %s" % data)
conn.close()
s.close()
def startAdvertising(self):
self.cv.acquire()
if not self.advertising:
self.devid = self.intrf.request(bandwidth=0)
self.obexsocket = lightblue.socket()
self.obexsocket.bind(("", 0))
lightblue.advertise("OBEX Object Push", self.obexsocket, lightblue.OBEX)
print "[OXR] Advertising OBEX Object Push on interface hci%d" % self.devid
self.advertising = True
self.cv.notify()
self.cv.release()
return self.devid
def lightblue_server_test():
# L2CAP server sockets not currently supported :(
s = lightblue.socket(lightblue.L2CAP)
s.bind(("", 0x1001))
s.listen(1)
lightblue.advertise("Peach", s, lightblue.L2CAP)
conn, addr = s.accept()
print("Connected by", addr)
data = conn.recv(1024)
print("Received: %s" % data)
conn.close()
s.close()
def initMessageAdvertisements(self):
"""Initialize the advertisement of hashes that have been sent to us."""
# @TODO@ Use the correct database here :-)
#self.database.query('select * from FluidNexusStigmergy')
self.database.services()
self.messageHashes = []
for item in self.database:
# @TODO@ This can break if we change the database schema
# Get the last item (the hash)
self.messageHashes.append('%s' % item[-1])
# If there is nothing in the FluidNexusStigmergy database, return now
if len(self.messageHashes) == 0:
return
# @HACK@
# For some reason we have to do this convoluted process below, otherwise sockets get reused or don't advertise properly.
# Meaning, we have to create the sockets beforehand, and then loop through them to advertise with the desired hashes.
# This seems strange, because we create the sockets anew before we advertise them, so it seems like some kind of race condition.
# Get the number of hashes to advertise
numAdvertise = len(self.messageHashes)
# Create all of our advertisingSockets
self.advertisingSockets = {}
for counter in range(0, len(self.messageHashes)):
if (self.library == "e32"):
self.advertisingSockets[self.messageHashes[counter]] = socket.socket(socket.AF_BT, socket.SOCK_STREAM)
elif (self.library == "lightblue"):
self.advertisingSockets[self.messageHashes[counter]] = lightblue.socket()
# Now, do what we need to with the sockets
for item in self.advertisingSockets.items():
hash = item[0]
s = item[1]
if (self.library == "e32"):
tempPort = socket.bt_rfcomm_get_available_server_channel(s)
s.bind(("", tempPort))
s.listen(1)
socket.bt_advertise_service(unicode(':' + hash), s, True, socket.RFCOMM)
elif (self.library == "lightblue"):
s.bind(("", 0))
s.listen(1)
lightblue.advertise(unicode(':' + hash), s, lightblue.RFCOMM)
def run(self):
server_socket = lightblue.socket(lightblue.RFCOMM)
server_socket.bind((" ", 0))
server_socket.listen(1)
lightblue.advertise("test_service", server_socket, lightblue.RFCOMM)
self.connected_socket, self.connected_client_address = server_socket.accept(
)
print "Connected by ", self.connected_client_address
connected_thread = BtConnectedThread(
connected_socket=self.connected_socket,
connected_client_address=self.connected_client_address)
connected_thread.start()
server_socket.close()
def run(self):
s = lightblue.socket()
s.bind(("", 0))
s.listen(2)
lightblue.advertise("SMS Gateway (Request Thread)", s,
lightblue.RFCOMM)
conn, addr = s.accept()
print "Connected to Request Server", addr
while 1:
resp = conn.recv(1024)
print resp
msg = SMS(resp)
db = database()
db.pushInboxMsg(msg.id, msg.to, msg.frm, msg.text, msg.timestamp)
conn.close()
s.close()
def setupBluetooth():
global conn
global sock
# Listen for Bluetooth connections
sock = lightblue.socket()
sock.bind(("", 0)) # bind to 0 to bind to a dynamically assigned channel
sock.listen(1)
lightblue.advertise("EchoService", sock, lightblue.RFCOMM)
print "Advertised and listening on channel %d..." % sock.getsockname()[1]
# Accept the first incoming connection
conn, addr = sock.accept()
print "Connected by", addr
# Send the start command to Glass
conn.send("start")
def bkservice():
"""备份服务"""
sock_server=lightblue.socket()
sock_server.bind(('',0))
sock_server.listen(1)
lightblue.advertise(u'bkservice',sock_server,lightblue.RFCOMM)
conn,addr=sock_server.accept()
print 'Client [%s] connected!'%repr(addr)
#conn.settimeout(5)
#print dir(conn)
try:
bksession(conn)
except:
traceback.print_exc()
finally:
conn.close()
return
def advertiseNewHash(self, hash):
"""Advertise a new hash that we have just received."""
log.write(str(hash))
if (self.library == "e32"):
newSocket = socket.socket(socket.AF_BT, socket.SOCK_STREAM)
self.advertisingSockets[hash] = newSocket
tempPort = socket.bt_rfcomm_get_available_server_channel(newSocket)
newSocket.bind(("", tempPort))
newSocket.listen(1)
socket.bt_advertise_service(unicode(':' + hash), newSocket, True, socket.RFCOMM)
elif (self.library == "lightblue"):
newSocket = lightblue.socket()
self.advertisingSockets[hash] = newSocket
newSocket.bind(("", 0))
newSocket.listen(1)
lightblue.advertise(unicode(":" + hash), newSocket, lightblue.RFCOMM)
def receive(self):
self.log("Dump your data...")
s = lightblue.socket()
s.bind(("", 0))
lightblue.advertise("My OBEX Service", s, lightblue.OBEX)
try:
while True:
(addr, fname) = lightblue.obex.recvfile(s, "tmp.dat")
if fname is not None:
fullname = serial_filename(settings.MEDIA_ROOT + "incoming/" + fname)
fname = "incoming/" + fullname.split("/")[-1]
os.rename("tmp.dat", fullname)
# find device
try:
device = Device.objects.get(device_id = addr);
except Device.DoesNotExist:
device = Device(device_id = id, name = name)
self.log("New device: %s" % device)
device.save()
recv = DeviceReceived(device = device, filename = fname)
recv.recv_time = datetime.now()
recv.save()
self.log("Got %s from %s" % (fname, device))
else:
self.log("Receive error...")
except Exception, e:
print e
print "Bye..."
s.close()
def run(self):
'''
server_sock=BluetoothSocket( RFCOMM )
server_sock.bind(("",PORT_ANY))
server_sock.listen(1)
port = server_sock.getsockname()[1]
uuid = "00001073-0000-1000-8000-00805F9B34F7"
advertise_service( server_sock, "TTTService",
service_id = uuid,
service_classes = [ uuid, SERIAL_PORT_CLASS ],
profiles = [ SERIAL_PORT_PROFILE ] )
'''
server_sock = lightblue.socket()
server_sock.bind(("", 0)) # bind to 0 to bind to a dynamically assigned channel
server_sock.listen(1)
lightblue.advertise("TTTService", server_sock, lightblue.RFCOMM)
port = server_sock.getsockname()[1]
print "Advertised and listening on channel %d..." % server_sock.getsockname()[1]
while not self.shutdown:
print "Waiting for connection on RFCOMM channel %d" % port
client_sock, client_info = server_sock.accept()
client_thread = ClientThread(self.processClientConnection, client_sock, client_info)
client_thread.start()
#client_thread.join()
server_sock.close()
print "Bluetooth Sync Server Terminated"
"""
Shows how to run a RFCOMM server socket.
"""
import lightblue
# create and set up server socket
sock = lightblue.socket()
sock.bind(("", 0)) # bind to 0 to bind to a dynamically assigned channel
sock.listen(1)
lightblue.advertise("EchoService", sock, lightblue.RFCOMM)
print "Advertised and listening on channel %d..." % sock.getsockname()[1]
conn, addr = sock.accept()
print "Connected by", addr
data = conn.recv(1024)
print "Echoing received data:", data
conn.send(data)
# sometimes the data isn't sent if the connection is closed immediately after
# the call to send(), so wait a second
import time
time.sleep(1)
conn.close()
sock.close()
import lightblue
port = 5
s = lightblue.socket()
s.bind(('', port))
s.listen(1)
print 'Listening on port', port
lightblue.advertise('Arm Launcher', s, lightblue.RFCOMM)
connection, address = s.accept()
print 'Accepted connection from', address
while True:
data = connection.recv(1024)
if not data:
break
print 'Received [%s]' % data
connection.close()
s.close()
#!/usr/bin/env python3
import lightblue
sock = lightblue.socket()
try:
sock.bind(("localhost", 0)) # bind to 0 to bind to a dynamically assigned channel
lightblue.advertise("OBEX File Transfer", sock, lightblue.OBEX)
# Receive a file and save it as MyFile.txt.
# This will wait and block until a file is received.
print( "Waiting to receive file on channel %d..." % sock.getsockname()[1])
lightblue.obex.recvfile(sock, "MyFile.txt")
finally:
sock.close()
print("Saved received file to MyFile.txt!")
"""
Shows how to run a RFCOMM server socket.
"""
import lightblue
# create and set up server socket
sock = lightblue.socket()
sock.bind(("", 0)) # bind to 0 to bind to a dynamically assigned channel
sock.listen(1)
lightblue.advertise("EchoService", sock, lightblue.RFCOMM)
print "Advertised and listening on channel %d..." % sock.getsockname()[1]
conn, addr = sock.accept()
print "Connected by", addr
while (True):
data = str(conn.recv(1024))
print "Echoing received data:", data
conn.send("Server received message!")
# sometimes the data isn't sent if the connection is closed immediately after
# the call to send(), so wait a second
import time
time.sleep(1)
conn.close()
sock.close()
"""
Shows how to receive a file over OBEX.
"""
import lightblue
# bind the socket, and advertise an OBEX service
sock = lightblue.socket()
try:
sock.bind(("", 0)) # bind to 0 to bind to a dynamically assigned channel
lightblue.advertise("LightBlue example OBEX service", sock, lightblue.OBEX)
# Receive a file and save it as MyFile.txt.
# This will wait and block until a file is received.
print "Waiting to receive file on channel %d..." % sock.getsockname()[1]
lightblue.obex.recvfile(sock, "MyFile.txt")
finally:
sock.close()
print "Saved received file to MyFile.txt!"
# Please note:
#
# To use a file through this example, the other device must send the file to
# the correct channel. E.g. if this example prints "Waiting to receive file on
# channel 5..." the remote device must send the file specifically to channel 5.
#
# * But what if you can't specify a channel or service?
#
# If you can send a file to a specific channel - e.g. by using
# Start servos at center point (90 degrees)
base.start(angleToPos(90))
arm.start(angleToPos(90))
forearm.start(angleToPos(90))
gripper.start(angleToPos(10))
# Initialize bluetooth on a specific port
port = 5
s = lightblue.socket()
s.bind(('', port))
s.listen(1)
print 'Listening on port', port
# Advertise bluetooth connection and wait for connection
lightblue.advertise('Arm Launcher', s, lightblue.RFCOMM)
connection, address = s.accept()
print 'Accepted connection from', address
while True:
data = connection.recv(1024)
if data == 'Done':
print 'Done command received'
break
try:
baseAngle, armAngle, forearmAngle, gripperAngle = (float(angle) for angle in data.split(','))
except:
continue
base.ChangeDutyCycle(angleToPos(baseAngle))
arm.ChangeDutyCycle(angleToPos(armAngle))
forearm.ChangeDutyCycle(angleToPos(forearmAngle))
"""
Shows how to receive a file over OBEX.
"""
import lightblue
# bind the socket, and advertise an OBEX service
sock = lightblue.socket()
try:
sock.bind(("", 0)) # bind to 0 to bind to a dynamically assigned channel
lightblue.advertise("LightBlue example OBEX service", sock, lightblue.OBEX)
# Receive a file and save it as MyFile.txt.
# This will wait and block until a file is received.
print "Waiting to receive file on channel %d..." % sock.getsockname()[1]
lightblue.obex.recvfile(sock, "MyFile.txt")
finally:
sock.close()
print "Saved received file to MyFile.txt!"
# Please note:
#
# To use a file through this example, the other device must send the file to
# the correct channel. E.g. if this example prints "Waiting to receive file on
# channel 5..." the remote device must send the file specifically to channel 5.
#
# * But what if you can't specify a channel or service?
#
