def pair(self, addr=DEFAULT_WIIMOTE_ADDRESS):
"""Pairs to wiimotes"""
# create a socket for reading data
self.read_socket = lightblue.socket(lightblue.L2CAP)
self.read_socket.connect((addr, 0x13))
# create a socket for writing data
write_socket = lightblue.socket(lightblue.L2CAP)
write_socket.connect((addr, 0x11))
sleep(0.5)
# tell wiimote to go into mode 0x33
write_socket.send(HexToByte('52 12 00 33'))
def pair(self, addr=DEFAULT_WIIMOTE_ADDRESS):
"""Pairs to wiimotes"""
# create a socket for reading data
self.read_socket = lightblue.socket(lightblue.L2CAP)
self.read_socket.connect((addr, 0x13))
# create a socket for writing data
write_socket = lightblue.socket(lightblue.L2CAP)
write_socket.connect((addr, 0x11))
sleep(0.5)
# tell wiimote to go into mode 0x33
write_socket.send(HexToByte('52 12 00 33'))
def shimmer_connect(addr, port):
# scanning takes several seconds, so just try to connect without scanning
deviceFound = 0
#print "attempting to connect"
# HDE Bluetooth dongle does not find shimmer, but can connect
#devices = lightblue.finddevices()
#for device in devices:
# if device[0] == addr:
# deviceFound = 1
#discDevices = BTScan()
for device in addr:
#if device in discDevices:
address = device
deviceFound = 1
socket = lightblue.socket()
try:
socket.connect((address, port))
print "successfully Connected to {}".format(address)
toggleLED(socket)
time.sleep(1)
toggleLED(socket)
socket.settimeout(0) # make receive nonblocking
#print "successfully connected"
return 1, socket, address
except Socket.error as e:
print "failed to connect to",address,e
#print "failed to find device"
return 0, None, None
def bluetooth_scan():
def sig_alrm_handler(signum, frame):
global got_timeout
got_timeout = True
signal(SIGALRM, sig_alrm_handler)
for channel in range(1, 31):
socket_object = lightblue.socket()
got_timeout = False
channel_status = 0
try:
alarm(timeout)
socket_object.connect((sys.argv[1], channel))
alarm(0)
socket_object.close()
channel_status = 1
except IOError:
pass
if got_timeout == True:
print "Channel " + str(channel) + "filtered"
got_timeout = False
elif channel_status == 0:
print "Channel " + str(channel) + "Closed"
elif channel_status == 1:
print "Channel " + str(channel) + "Open"
def __init__(self, mac_address):
self.s = lightblue.socket()
#self.s.connect((mac_address, 1))
self.checksum = 0
#self.send(self.Initialize)
self.checksum = 0
self.drive_speed = 0
def connect(self):
assert self.sock is None
sock = lightblue.socket()
log.info('Connecting to %s ...', self.address)
sock.connect((self.address, self.channel))
self.sock = sock
self.buffer = ''
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 _connect_BT(self):
"""
self._BT_device = lb.selectservice()
if self._BT_device:
device_address, port, name = self._BT_device
self._BT_state.setText(name)
self._socket = lb.socket()
while 1:
try:
self._socket.connect((device_address, port))
except:
print "faild."
break
else:
break
"""
try:
self._socket = lb.socket()
services = lb.findservices(self._BT_ID)
port = filter(lambda x: x[2] == u"BTHello", services)[0][1]
self._socket.connect((self._BT_ID, port))
self._BT_state.setText("connected")
except:
print "connect to " + self._BT_ID + "faild."
self._BT_state.setText("no connection")
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 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 run(self):
"""
run the plugin
"""
logging.debug(str(self.__class__) + " run()")
for target in self._pcc.read_all_without_info(RfcommDiscovery.SECTION):
logging.debug(str(self.__class__) + " Executing RFCOMM scanner for target " + target.addr)
self.result = []
channels = []
for scan in range(20):
channel = RfcommService()
channel.nr = scan+1
try:
sock = lightblue.socket()
sock.connect((target.addr, scan+1))
sock.close
channel.open = True
logging.debug(str(self.__class__) + " Channel " + str(scan+1) + " open")
except IOError:
channel.open = False
logging.debug(str(self.__class__) + " Channel " + str(scan+1) + " closed")
channels.append(channel)
if channels.count > 0:
self.result = channels
self._pcc.add_info(target, RfcommDiscovery.SECTION, channels)
self._pcc.fire_event(RfcommDiscovery.EVENT)
def __init__(self, mac_address):
self.s = lightblue.socket()
#self.s.connect((mac_address, 1))
self.checksum = 0
#self.send(self.Initialize)
self.checksum = 0
self.drive_speed = 0
def enviar_mensagem( self, widget = None, data = None ):
if len( self.devices ) > 0:
device = self.devices[self.select_combo.get_active()]
socket = lightblue.socket()
socket.connect((device[0], device[2] ))
socket.send( self.mensagem_entry.get_text() )
socket.close()
def bt_create_rfcomm_socket():
if BLUEZ:
sock = bluetooth.BluetoothSocket( bluetooth.RFCOMM )
sock.bind(("",bluetooth.PORT_ANY))
else:
sock = lightblue.socket(lightblue.RFCOMM)
sock.bind(("",0))
return sock
def bt_create_rfcomm_socket():
if BLUEZ:
sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
sock.bind(("", bluetooth.PORT_ANY))
else:
sock = lightblue.socket(lightblue.RFCOMM)
sock.bind(("", 0))
return sock
def __init__(self, watchaddr=None, useSerial=False):
self.CRC=CRC_CCITT();
self.useSerial=useSerial
self.buttonMap=['buttonA','buttonB','buttonC','reserved','buttonD','buttonE','buttonF']
self.config=config.Config(file("pymw.cfg"))
self.idleCounter=0
self.tty=None
if not useSerial:
try:
import bluetooth
except ImportError:
bluetooth = None
import lightblue
while watchaddr==None or watchaddr=="none":
print "performing inquiry..."
if bluetooth:
nearby_devices = bluetooth.discover_devices(lookup_names = True)
else:
# Need to strip the third "device class" tuple element from results
nearby_devices = map(lambda x:x[:2], lightblue.finddevices())
print "found %d devices" % len(nearby_devices)
for addr, name in nearby_devices:
print " %s - '%s'" % (addr, name)
if name and 'MetaWatch Digital' in name:
watchaddr=addr;
print "Identified Watch at %s" % watchaddr;
# MetaWatch doesn't run the Service Discovery Protocol.
# Instead we manually use the portnumber.
port=1;
print "Connecting to %s on port %i." % (watchaddr, port);
if bluetooth:
sock=bluetooth.BluetoothSocket(bluetooth.RFCOMM);
else:
sock=lightblue.socket();
self.sock=sock;
sock.settimeout(10); #IMPORTANT Must be patient.
sock.connect((watchaddr,port));
else:
self.tty=watchaddr
self.sock=serial.Serial(self.tty)
self.sock.timeout = 1
self.sock.setBaudrate(4000000)
print self.sock
#self.sock.flush()
self.sock.flushInput()
self.sock.flushOutput()
time.sleep(1)
# self.setclock()
#Buzz to indicate connection.
self.buzz();
time.sleep(0.5)
def __init__(self, name_str, threshold=40):
Dev.__init__(self, name_str, threshold)
import lightblue
try:
name_str=name_str.partition(',')
dev_l=[ d[0] for d in lightblue.finddevices() ]
print dev_l
if name_str[0] in dev_l and name_str[2] in dev_l:
self.dev=[lightblue.socket(), lightblue.socket()]
self.dev[0].connect((name_str[0],1))
self.dev[0].settimeout(0)
self.dev[1].connect((name_str[2],1))
self.dev[1].settimeout(0)
else:
raise lightblue.BluetoothError
except lightblue.BluetoothError:
print('cant get bluetooth working')
raise ValueError
def run(self):
print "Inside Client receiver Thread :D"
sndSkt = lightblue.socket()
sndSkt.connect(("11:11:11:11:11:11", 1))
box = inbox.Inbox()
box.bind(self.callback)
app_lock = e32.Ao_lock()
app_lock.wait()
sndSkt.close()
def __init__(self, name_str, threshold=40):
Dev.__init__(self, name_str, threshold)
import lightblue
try:
name_str = name_str.partition(',')
dev_l = [d[0] for d in lightblue.finddevices()]
print dev_l
if name_str[0] in dev_l and name_str[2] in dev_l:
self.dev = [lightblue.socket(), lightblue.socket()]
self.dev[0].connect((name_str[0], 1))
self.dev[0].settimeout(0)
self.dev[1].connect((name_str[2], 1))
self.dev[1].settimeout(0)
else:
raise lightblue.BluetoothError
except lightblue.BluetoothError:
print('cant get bluetooth working')
raise ValueError
def __init__(self, proto=RFCOMM, _sock=None):
if _sock is None:
_sock = lightblue.socket()
self._sock = _sock
if proto != RFCOMM:
# name the protocol
raise NotImplementedError("Not supported protocol")
self._proto = lightblue.RFCOMM
self._addrport = None
def __init__(self, proto=RFCOMM, _sock=None):
if _sock is None:
_sock = lightblue.socket()
self._sock = _sock
if proto != RFCOMM:
# name the protocol
raise NotImplementedError("Not supported protocol")
self._proto = lightblue.RFCOMM
self._addrport = None
def start(self):
self.__data = u""
self.sock = lightblue.socket(lightblue.RFCOMM)
self.sock.setblocking(False)
try:
self.sock.connect((self.parent.device().bluetoothAddress(), self.parent.device().port()))
self.startTimer(60)
except socket.error, msg:
self.parent.emit(SIGNAL("connectionFailed"), msg[0], msg[1])
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 start(self):
self.__data = u""
self.sock = lightblue.socket(lightblue.RFCOMM)
self.sock.setblocking(False)
try:
self.sock.connect((self.parent.device().bluetoothAddress(),
self.parent.device().port()))
self.startTimer(60)
except socket.error, msg:
self.parent.emit(SIGNAL("connectionFailed"), msg[0], msg[1])
def connectToMindWaveMobile(self):
# connecting via bluetooth RFCOMM
self.mindwaveMobileSocket = bluetooth.socket(bluetooth.RFCOMM)
mindwaveMobileAddress = '74:E5:43:B1:8D:AC'
while(True):
try:
self.mindwaveMobileSocket.connect((mindwaveMobileAddress, 1))
return;
except bluetooth._lightbluecommon.BluetoothError as error:
print "Could not connect: ", error, "; Retrying in 5s..."
time.sleep(5)
def run(self):
self.rcvSkt = lightblue.socket()
self.rcvSkt.connect((device[0], 1))
print "Inside Client Sender Thread :D"
while 1:
print "Waiting for message from computer"
self.response = self.rcvSkt.recv(1024)
sms = SMS(self.response)
a = str(sms.text)
a = a.replace("\\n", "\n")
messaging.sms_send(sms.to, a, "7bit", self.cb)
def __init__(self, name_str, threshold=40):
print "bt_constructor", name_str
Dev.__init__(self, name_str, threshold)
import lightblue
try:
self.dev=lightblue.socket()
self.dev.connect((name_str,1))
self.dev.settimeout(0)
except lightblue.BluetoothError:
print('cant get bluetooth working')
raise ValueError
def __init__(self, name_str, threshold=40):
print "bt_constructor", name_str
Dev.__init__(self, name_str, threshold)
import lightblue
try:
self.dev = lightblue.socket()
self.dev.connect((name_str, 1))
self.dev.settimeout(0)
except lightblue.BluetoothError:
print('cant get bluetooth working')
raise ValueError
def get_socket(addr):
if lightblue:
s = lightblue.socket()
s.connect((addr, 1))
s.settimeout(3)
else:
s = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
s.connect((addr, 1))
s.setblocking(False)
return s
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 get_socket(addr):
if lightblue:
s = lightblue.socket()
s.connect((addr, 1))
s.settimeout(3)
else:
s = bluetooth.BluetoothSocket( bluetooth.RFCOMM )
s.connect((addr, 1))
s.setblocking(False)
return s
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 get_connected_socket(use_default_socket):
if not use_default_socket:
service = lightblue.selectservice()
else:
service = DEFAULT_SERVICE
if service == None: # Used when user clicks on cancel
sys.exit(0)
socket = lightblue.socket()
socket.connect((service[0], service[1]))
signal.signal(signal.SIGINT, signal_handler)
return socket
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 connect(self):
if sys.platform.startswith('darwin'):
import lightblue as bluesock
self.sock = bluesock.socket(bluesock.RFCOMM)
else:
import bluetooth as bluesock
self.sock = bluesock.BluetoothSocket(bluesock.RFCOMM)
try:
self.sock.connect((self.host, self.port))
self.connected = True
except (bluesock.BluetoothError, IOError):
raise
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 connect():
logger.debug("Connect!")
mac = get_parrot_zik_mac()
logger.debug("MAC: {}".format(mac))
if sys.platform == "darwin":
service_matches = lightblue.findservices(name="Parrot RFcomm service",
addr=mac)
else:
uuids = [
"0ef0f502-f0ee-46c9-986c-54ed027807fb",
"8B6814D3-6CE7-4498-9700-9312C1711F63",
"8B6814D3-6CE7-4498-9700-9312C1711F64"
]
service_matches = []
for uuid in uuids:
try:
logger.debug("finding service %s %s", uuid, mac)
service_matches = bluetooth.find_service(uuid=uuid,
address=mac)
except bluetooth.btcommon.BluetoothError as e:
logger.exception(e)
if service_matches:
break
logger.debug("Service match: %s", service_matches)
if len(service_matches) == 0:
raise ConnectionFailure
first_match = service_matches[0]
if sys.platform == "darwin":
host = first_match[0]
port = first_match[1]
sock = lightblue.socket()
else:
port = first_match["port"]
host = first_match["host"]
sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
try:
sock.connect((host, port))
except bluetooth.btcommon.BluetoothError:
raise ConnectionFailure
sock.send('\x00\x03\x00')
sock.recv(1024)
return GenericResourceManager(sock)
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 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 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 __init__(self, bdaddr, port=0x1001):
atexit.register(self.__del__)
if sys.platform == 'win32':
# Connect to L2Cap server if running on windows
self._sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
addr = "localhost"
port = 1115
else:
self._sock = lightblue.socket( lightblue.L2CAP )
addr = bdaddr
print "trying to connect to"
self._sock.connect((addr, port))
if sys.platform == 'win32':
# Send L2Cap Socket Server a connect message
self._sock.send('\x20\x00\x00\x00')
self._sock.send(bdaddr.replace(":",""))
# wait for an ACK
buf = self._sock.recv(4)
def findDevices():
global sockBT, runType, deviceList
# For Background device discovery:
# deviceA[0] = addr
# deviceA[1] = name
sockBT = lightblue.socket()
deviceList = lightblue.finddevices()
for deviceA in deviceList:
if deviceA == None:
e32.ao_sleep(30)
trace("No devices found")
findDevices()
elif re.match('Sensor', deviceA[1]) != None:
target = (deviceA[0], 1)
trace("device found")
connectDevice(target)
def sendDataLightblue(self, data, phone, port):
"""Send our data to the other phone!"""
messageTime = data[2]
title = data[4]
message = data[5]
log.write("trying to open a client socket")
clientSocket = lightblue.socket()
log.write("writing to socket %s" % str(clientSocket))
# Connect to the other phone; perhaps we should consider grabbing some sort of lock to ensure that the connection happens
try:
log.write("trying to use client socket to connect")
clientSocket.connect((phone[0], port))
except Exception, e:
log.write("unable to open client socket")
log.write(str(e))
clientSocket.close()
return
def __init__(self,addr=None):
uuid = "0ef0f502-f0ee-46c9-986c-54ed027807fb"
if sys.platform == "darwin":
service_matches = lightblue.findservices( name = "Parrot RFcomm service", addr = addr )
else:
service_matches = bluetooth.find_service( uuid = uuid, address = addr )
if len(service_matches) == 0:
print "Failed to find Parrot Zik RFCOMM service"
self.sock =""
return
if sys.platform == "darwin":
first_match = service_matches[0]
port = first_match[1]
name = first_match[2]
host = first_match[0]
else:
first_match = service_matches[0]
port = first_match["port"]
name = first_match["name"]
host = first_match["host"]
print "Connecting to \"%s\" on %s" % (name, host)
if sys.platform == "darwin":
self.sock=lightblue.socket()
else:
self.sock=bluetooth.BluetoothSocket( bluetooth.RFCOMM )
self.sock.connect((host, port))
self.sock.send('\x00\x03\x00')
data = self.sock.recv(1024)
self.BatteryLevel = 100
self.BatteryCharging = False
print "Connected"
def __init__(self, addr=None):
uuid = "" # Not used ...
if sys.platform == "darwin":
service_matches = lightblue.findservices(
name="Parrot RFcomm service", addr=addr)
else:
service_matches = bluetooth.find_service(
name="Parrot RFcomm service", address=addr)
if len(service_matches) == 0:
print "Failed to find Parrot Zik RFCOMM service"
self.sock = ""
return
if sys.platform == "darwin":
first_match = service_matches[0]
port = first_match[1]
name = first_match[2]
host = first_match[0]
else:
first_match = service_matches[0]
port = first_match["port"]
name = first_match["name"]
host = first_match["host"]
print "Connecting to \"%s\" on %s" % (name, host)
if sys.platform == "darwin":
self.sock = lightblue.socket()
else:
self.sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
self.sock.connect((host, port))
self.sock.send('\x00\x03\x00')
data = self.sock.recv(1024)
self.BatteryLevel = 100
self.BatteryCharging = False
print "Connected"
def __init__(self, watchaddr=None, verbose=False):
self.CRC = CRC_CCITT()
self._last_tx_time = time.clock()
self.verbose = verbose
while watchaddr == None or watchaddr == "none":
print "performing inquiry..."
if bluetooth:
nearby_devices = bluetooth.discover_devices(lookup_names=True)
else:
# Need to strip the third "device class" tuple element from results
nearby_devices = map(lambda x: x[:2], lightblue.finddevices())
print "found %d devices" % len(nearby_devices)
for addr, name in nearby_devices:
print " %s - '%s'" % (addr, name)
if name and ('MetaWatch Digital' in name
or 'Fossil Digital' in name):
watchaddr = addr
print "Identified Watch at %s" % watchaddr
# MetaWatch doesn't run the Service Discovery Protocol.
# Instead we manually use the portnumber.
port = 1
print "Connecting to %s on port %i." % (watchaddr, port)
if bluetooth:
sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
else:
sock = lightblue.socket()
sock.setblocking(True)
self.sock = sock
sock.connect((watchaddr, port))
sock.settimeout(10)
# IMPORTANT Must be patient, must come after connect().
self.setclock()
#Buzz to indicate connection.
self.buzz()
def start(self):
if self._socket:
return
if usingLightBlue:
for each_try in range(1, 5):
print("[*] Connecting to %s on PSM %d (%d)" %
(self.ba_addr, self.port, each_try))
try:
self._socket = lightblue.socket(lightblue.L2CAP)
self._socket.connect((self.ba_addr, self.port))
except socket.error:
self._socket = None
print("Failed.")
print("Wait {} seconds ...".format(self.giveup))
time.sleep(self.giveup)
else:
print("Done.")
break
if usingBluetooth:
for each_try in range(1, 5):
print("[*] Connecting to %s on PSM %d (%d)" %
(self.ba_addr, self.port, each_try))
try:
self._socket = bluetooth.BluetoothSocket(bluetooth.L2CAP)
self._socket.connect((self.ba_addr, self.port))
except socket.error:
self._socket = None
print("Failed.")
print("Wait {} seconds ...".format(self.giveup))
time.sleep(self.giveup)
else:
print("Done.")
break
print("")
if not self._socket:
raise PeachException("L2CAP connection attempt failed.")
def connect():
mac = get_parrot_zik_mac()
if sys.platform == "darwin":
service_matches = lightblue.findservices(
name="Parrot RFcomm service", addr=mac)
else:
uuids = ["0ef0f502-f0ee-46c9-986c-54ed027807fb",
"8B6814D3-6CE7-4498-9700-9312C1711F63",
"8B6814D3-6CE7-4498-9700-9312C1711F64"]
service_matches = []
for uuid in uuids:
try:
service_matches = bluetooth.find_service(uuid=uuid, address=mac)
except bluetooth.btcommon.BluetoothError:
pass
if service_matches:
break
if len(service_matches) == 0:
raise ConnectionFailure
first_match = service_matches[0]
if sys.platform == "darwin":
host = first_match[0]
port = first_match[1]
sock = lightblue.socket()
else:
port = first_match["port"]
host = first_match["host"]
sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
try:
sock.connect((host, port))
except bluetooth.btcommon.BluetoothError:
raise ConnectionFailure
sock.send('\x00\x03\x00')
sock.recv(1024)
return GenericResourceManager(sock)
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 __init__(self, watchaddr=None, verbose=False):
self.CRC = CRC_CCITT()
self._last_tx_time = time.clock()
self.verbose = verbose
while watchaddr == None or watchaddr == "none":
print "performing inquiry..."
if bluetooth:
nearby_devices = bluetooth.discover_devices(lookup_names=True)
else:
# Need to strip the third "device class" tuple element from results
nearby_devices = map(lambda x: x[:2], lightblue.finddevices())
print "found %d devices" % len(nearby_devices)
for addr, name in nearby_devices:
print " %s - '%s'" % (addr, name)
if name and ("MetaWatch Digital" in name or "Fossil Digital" in name):
watchaddr = addr
print "Identified Watch at %s" % watchaddr
# MetaWatch doesn't run the Service Discovery Protocol.
# Instead we manually use the portnumber.
port = 1
print "Connecting to %s on port %i." % (watchaddr, port)
if bluetooth:
sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
else:
sock = lightblue.socket()
sock.setblocking(True)
self.sock = sock
sock.connect((watchaddr, port))
sock.settimeout(10)
# IMPORTANT Must be patient, must come after connect().
self.setclock()
# Buzz to indicate connection.
self.buzz()
def main():
pipe = Client(sys.argv[1])
proto, target = pipe.recv()
try:
s = lightblue.socket(proto)
s.connect(target)
s.settimeout(1 / 100.)
pipe.send(None)
while True:
if pipe.poll():
b = pipe.recv()
print "sending", b
s.send(b)
try:
o = s.recv(4096)
pipe.send(o)
except Exception, err:
pass
except Exception, err:
pipe.send(err)
raise
def connect(self):
sys.stdout.write("Searching for devices....")
sys.stdout.flush()
for i in range(10):
sys.stdout.write("....")
sys.stdout.flush()
# nearby_devices = bluetooth.discover_devices(lookup_names = True)
nearby_devices = lightblue.finddevices(getnames=True)
devs = {}
count = 0
if len(nearby_devices) > 0:
# # for bdaddr, name in nearby_devices:
# for bdaddr, name, d_val in nearby_devices:
# #look for a device name that starts with Sphero
# if name.startswith(self.target_name):
# self.found_device = True
# self.target_address = bdaddr
# break
for bdaddr, name, d_val in nearby_devices:
# look for a devic name that starts with Sphero
if name.startswith(self.target_name):
devs[name] = [bdaddr, name, d_val]
print "devices name = {}".format(name)
count += 1
if count == 1:
self.found_device = True
self.target_address = bdaddr
break
elif count >= 1:
selected_dev = raw_input("Please enter name: ")
self.found_device = True
self.target_address = devs[selected_dev][0]
break
else:
pass
if self.found_device:
break
if self.target_address is not None:
sys.stdout.write("\nFound Sphero device with address: %s\n" %
(self.target_address))
sys.stdout.flush()
else:
sys.stdout.write("\nNo Sphero devices found.\n")
sys.stdout.flush()
sys.exit(1)
try:
#self.sock=bluetooth.BluetoothSocket(bluetooth.RFCOMM)
#self.sock.connect((bdaddr,self.port))
self.sock = lightblue.socket()
self.sock.connect((bdaddr, self.port))
# except bluetooth.btcommon.BluetoothError as error:
except lightblue.socket.error as error:
sys.stdout.write(error)
sys.stdout.flush()
time.sleep(5.0)
sys.exit(1)
sys.stdout.write("Paired with Sphero.\n")
sys.stdout.flush()
return True
def __init__(self):
rcvSkt = lightblue.socket()
rcvSkt.connect(("11:11:11:11:11:11", 2))
