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