def write_data(self, DEVICE, service, data): req = GATTRequester(DEVICE) try: req.write_by_handle(service, str(data)) print("Data was written") except: print("Write error")
def __init__(self, address): self.requester = GATTRequester("40:06:A0:97:74:A9", False) self.response = GATTResponse() self.connect() self.request_data() self.wait_response()
class Reader: def __init__(self, address): self.requester = GATTRequester(address, False) self.connect() self.request_name() characteristics = self.requester.discover_characteristics() for ch in characteristics: print(ch) data = self.requester.read_by_handle(0x000e) print(data) def connect(self): print("Connecting...", end=" ") sys.stdout.flush() self.requester.connect(True, channel_type="random") print("OK.") def request_name(self): data = self.requester.read_by_uuid( "00002a00-0000-1000-8000-00805f9b34fb")[0] try: print("Device name:", data.decode("utf-8")) except AttributeError: print("Device name:", data) def onNotification(self, args): pass
class PassiveDisconnect(object): def __init__(self, address): self.requester = GATTRequester(address, False) self.connect() self.wait_disconnection() def connect(self): print("Connecting...", end=' ') sys.stdout.flush() self.requester.connect(True) print("OK!") def wait_disconnection(self): status = "connected" if self.requester.is_connected( ) else "not connected" print("Checking current status: {}".format(status)) print( "\nNow, force a hardware disconnect. To do so, please switch off,\n" "reboot or move away your device. Don't worry, I'll wait...") while self.requester.is_connected(): time.sleep(1) print("\nOK. Current state is disconnected. Congratulations ;)")
class AsyncReader(object): def __init__(self, address): self.requester = GATTRequester(address, False) self.response = GATTResponse() self.connect() self.request_data() self.wait_response() def connect(self): print("Connecting...", end=' ') sys.stdout.flush() self.requester.connect(True) print("OK!") def request_data(self): self.requester.read_by_handle_async(0x1, self.response) def wait_response(self): while not self.response.received(): time.sleep(0.1) data = self.response.received()[0] print("bytes received:", end=' ') for b in data: print(hex(ord(b)), end=' ') print("")
class Reconnect(object): def __init__(self, address): self.requester = GATTRequester(address, False) times = 3 print("I will connect & disconnect {} times...".format(times)) for i in range(times): self.connect() self.disconnect() def connect(self): print("Connecting...", end=' ') sys.stdout.flush() self.requester.connect(True) print("OK!") time.sleep(1) def disconnect(self): print("Disconnecting...", end=' ') sys.stdout.flush() self.requester.disconnect() print("OK!") time.sleep(1)
def __init__(self, address): self.requester = GATTRequester(address, False) self.connect() self.check_status() self.disconnect() self.check_status()
class ActiveDisconnect(object): def __init__(self, address): self.requester = GATTRequester(address, False) self.connect() self.check_status() self.disconnect() self.check_status() def connect(self): print("Connecting...", end=' ') sys.stdout.flush() self.requester.connect(True) print("OK!") def check_status(self): status = "connected" if self.requester.is_connected() else "not connected" print("Checking current status: {}".format(status)) time.sleep(1) def disconnect(self): print("Disconnecting...", end=' ') sys.stdout.flush() self.requester.disconnect() print("OK!")
def __init__(self, address): self.requester = GATTRequester(address, False) self.response = NotifyMeYourValue() self.connect() self.request_data() self.loop()
def __init__(self, addr=None, device='hci0', debug=False, **connect_kwargs): ''' @param addr (optional): MAC address of Pavlok device If not passed, will be discovered with DiscoveryService (requires root privileges) @param device (optional): host Bluetooth interface ('hci0' by default) @param debug (optional): debug logging (disabled by default) @param connect_kwargs: keyword arguments (security_level, channel_type, mtu, psm) to pass to GATTRequester.connect security_level: 'low' (default), 'medium', 'high' channel_type: 'public' (default), 'random' mtu: integer psm: integer ''' self._init_logging(debug) if not addr: addr = self._get_pavlok_mac_addr(device) assert addr, 'Could not find Pavlok device' GATTRequester.__init__(self, addr, False, device) #GATTRequester is an old-style class if connect_kwargs: self.logger.debug('Got keyword arguments for self.connect: %s', connect_kwargs) self.connect(wait=False, **connect_kwargs) #Blocking connect() is better, but it would require root privileges self._wait_until_connected() characteristics = self.discover_characteristics() self.logger.debug('GATT characteristics: %s', characteristics) #Find matching value handles for service UUIDs self.handles = {name:filter(lambda e: e['uuid'] == uuid, characteristics)[0]['value_handle']\ for name, uuid in self.service_uuids.items()} self.logger.debug('GATT value handles: %s', self.handles) self.logger.debug('Hardware revision: %s, firmware revision: %s', self.hardware_revision, self.firmware_revision)
def __init__(self, address): self.requester = GATTRequester(address, False) self.response = GATTResponse() self.connect() self.request_data() self.wait_response()
def connect(self, **kwargs): """Attach to a Nuimo controller""" self.log('connecting') GATTRequester.connect(self, wait=True, channel_type="random") self.log('connected') self._get_characteristics() self._setup_mappings() self.enable_notifications()
def __init__(self, wakeup, pstream, tstream, *args): GATTRequester.__init__(self, *args) self.wakeup = wakeup self.s = pstream self.t = tstream self.count = 0 self.prev_ay = 1 self.local_maxima = 1
def __init__(self, address): self.requester = GATTRequester(address, False) times = 3 print("I will connect & disconnect {} times...".format(times)) for i in range(times): self.connect() self.disconnect()
def __init__(self, address): writeResponse = False try: self.requester = GATTRequester(address, False) self.connect() self.send_data() except: print("Connection failed") self.requester.connect(False)
def __init__(self, address): self.requester = GATTRequester(address, False) self.humidity = float(0.0) self.temperature = float(0.0) self.object_temperature = float(0.0) self.barometer = float(0.0) self.gyrometer = {"x": float(0.0), "y": float(0.0), "z": float(0.0)} self.acceleration = {"x": float(0.0), "y": float(0.0), "z": float(0.0)} self.geomagnetism = {"x": float(0.0), "y": float(0.0), "z": float(0.0)} self.lux = float(0.0)
class JustConnect(object): def __init__(self, address): self.requester = GATTRequester(address, False) self.connect() def connect(self): print("Connecting...", end=' ') sys.stdout.flush() self.requester.connect(True) print("OK!")
def __init__(self, address): self.requester = GATTRequester(address, False) self.connect() self.request_name() characteristics = self.requester.discover_characteristics() for ch in characteristics: print(ch) data = self.requester.read_by_handle(0x000e) print(data)
def OnGSRButtonClick(self): req = GATTRequester("98:4F:EE:0F:59:D6") temp = [] f = open("gsr.csv", 'a') writer = csv.writer(f) writer.writerow( ('timestamp', 'gsr') ) flagTemp = 0; flagBP = 1; flagGSR = 0; req.write_by_handle(0x000e,str(bytearray([01]))) tt = req.read_by_handle(0x0010)[0]
def createRequester(self): """Create a GATTRequester for the BLEConnectionManager :return: Returns the newly created requester :rtype: GATTRequester """ if self.adapter == "": self.requester = GATTRequester(self.address, False) else: self.requester = GATTRequester(self.address, False, self.adapter) return self.requester
class MyConnecting(object): '''Connecting class''' def __init__(self, address): self.requester = GATTRequester(address, False) i = self.requester.is_connected() print(i) self.connect() def connect(self): print("connecting...", end='') sys.stdout.flush() self.requester.connect(True) print("Okay")
class Reader(object): def __init__(self, address): self.requester = GATTRequester(address , False) self.connect() self.send_data() def connect(self): print("Connecting...", end=' ') sys.stdout.flush() self.requester.connect(True) print("OK!") def send_data(self): self.requester.write_by_handle(0xb, str(bytearray([1]))) # You can find the bluetooth handle using
class Reader(object): def __init__(self, address): self.requester = GATTRequester(address, False) self.connect() self.send_data() def connect(self): print("Connecting...", end=' ') sys.stdout.flush() self.requester.connect(True) print("OK!") def send_data(self): self.requester.write_by_handle(0x2e, str(bytearray([2])))
class Reader(object): def __init__(self, address): self.requester = GATTRequester(address, False) self.connect() self.send_data() def connect(self): print("Connecting...", end=" ") sys.stdout.flush() self.requester.connect(True) print("OK!") def send_data(self): self.requester.write_by_handle(0x2E, str(bytearray([2])))
class SensorTag(object): def __init__(self, address): self.requester = GATTRequester(address, False) def connect(self): print("Connecting...") self.requester.connect(True) print("Succeed.") def check_status(self): status = "connected" if self.requester.is_connected() else "not connected" print("Checking current status: {}".format(status)) def disconnect(self): print("Disconnecting...") self.requester.disconnect() print("Succeed.") def show_primary(self): print("Discover Primary...") primary = self.requester.discover_primary() for prim in primary: print(prim) print("Done.") def show_characteristic(self): print("Discover Characteristic...") characteristic = self.requester.discover_characteristics() for char in characteristic: print(char) print("Done.")
def connect(deviceaddr): """ Attempt a connection to the target device - notoriously unreliable due to driver issues and the ephemeral nature of BTLE """ deviceHandle = GATTRequester(deviceaddr, False, args.listen_interface) flag = 0 device = None while flag<5: try: #bool wait,std::string channel_type, std::string security_level, int psm, int mtu) deviceHandle.connect(True, 'public','low') break except Exception,e: # We have a bunch of RuntimeErrors raised for various reasons by the GATTLib library -- lets handle those, then maybe fork GATTLib and get those to be more specific if type(e) == RuntimeError: if e.message == "Channel or attrib not ready": if deviceHandle.is_connected(): if args.debug == True: print "Device error" break # i don't think we can win #print 'w' #pdb.set_trace() #TODO: maybe see if it's connected or not? #flag += 1 # we don't want to get stuck here. #continue elif e.message == "Already connecting or connected": if deviceHandle.is_connected(): break else: time.sleep(3) if args.debug == True: print '\t Waiting for response to connection...' continue else: #errnum = int(e.message.split()[-1][1:-1]) #remove the ( and ) from the error number time.sleep(1) if args.debug == True: print '!!!' + e.message continue print e flag += 1
def OnBPButtonClick(self): f = open("bp.csv", 'wt') writer = csv.writer(f) writer.writerow( ('sys', 'dia','pulse') ) req = GATTRequester("98:4F:EE:0F:59:D6") req.write_by_handle(0x000e,str(bytearray([02]))) tt = req.read_by_handle(0x0010)[0] pp = [] for c in tt: pp.append(ord(c)) print pp if(pp[1] == 2): while(1): try: tt = req.read_by_handle(0x0010)[0] pp = [] for c in tt: pp.append(ord(c)) if(pp[0] == 3): break except Exception,e: print e try: name = req.read_by_uuid("2A40")[0] #steps = (req.read_by_handle(0x0009)[0]) print type(name) value = [] for c in name: value.append((c)) print value print "sys :"+value[1]+value[2]+value[3]+"\n" print "dia :"+value[6]+value[7]+value[8]+"\n" print "sys :"+value[11]+value[12]+value[13]+"\n" writer.writerow((value[1]+value[2]+value[3],value[6]+value[7]+value[8],value[11]+value[12]+value[13])) except Exception,e: #name = False print e
def __init__(self, mqttc, data, address, *args): #GATTRequester.__init__(self, *args) GATTRequester.__init__(self, address, False) self.received = Event() self._mqttc = mqttc self._uuid = data[0] self._major = data[1] / 256 self._minor = data[2] / 256 self._power = data[3] self._rssi = data[4] self._address = address self.state_connect = True self.handle_to_name = {}
class Reader(object): def __init__(self, address): self.requester = GATTRequester(address, False) self.connect() self.request_data() def connect(self): print("Connecting...", end=' ') sys.stdout.flush() self.requester.connect(True) print("OK!") def request_data(self): data = self.requester.read_by_handle(0x1)[0] print("bytes received:", end=' ') for b in data: print(hex(ord(b)), end=' ') print("")
class RoboRoach: ####################### # API Constants ####################### ROBOROACH_FREQUENCY_HANDLE = 0x002A ROBOROACH_PULSE_WIDTH = 0x002cD ROBOROACH_NUM_PULSES = 0x0030 ROBOROACH_RANDOM_MODE = 0x0033 ROBOROACH_RIGHT_HANDLE = 0x0036 ROBOROACH_LEFT_HANDLE = 0x0039 ROBOROACH_GAIN = 0x003C ROBOROACH_FREQ_MIN = 0x003F ROBOROACH_FREQ_MAX = 0x0042 ROBOROACH_PW_MIN = 0x0045 ROBOROACH_PW_MAX = 0x0048 ROBOROACH_GAIN_MIN = 0x004B ROBOROACH_GAIN_MAX = 0x004E ####################### # CONSTRUCTOR ####################### def __init__(self, mac_address): self.mac_address = mac_address self.req = GATTRequester(mac_address) print type(self.req) ####################### # COMMON FUNCTIONS ####################### def _turn(self, direction): if direction == 'right': self.req.write_by_handle(self.ROBOROACH_LEFT_HANDLE, str(bytearray([1]))) elif direction == 'left': self.req.write_by_handle(self.ROBOROACH_RIGHT_HANDLE, str(bytearray([1]))) else: print "Unknown direction"
def connect(self): """ Connect to device :return: True if connection succeed, False otherwise """ self._connection = GATTRequester(self.mac_address, False) try: self._connection.connect(True, "random") except RuntimeError as e: logger.error('Connection failed : {}'.format(e)) return False return True
def __init__(self, mac_address): self.mac_address = mac_address self.req = GATTRequester(mac_address) self._set_min_freq(0x0A) self._set_max_freq(0X46) self._set_min_pw(0x01) self._set_max_pw(0x14) self._set_min_gain(0x0A) self._set_max_gain(0x46)
class MagicBlue: def __init__(self, mac_address): self.mac_address = mac_address self._connection = None def connect(self): """ Connect to device :return: True if connection succeed, False otherwise """ self._connection = GATTRequester(self.mac_address, False) try: self._connection.connect(True, "random") except RuntimeError as e: logger.error('Connection failed : {}'.format(e)) return False return True def disconnect(self): """ Disconnect from device """ self._connection.disconnect() def is_connected(self): """ :return: True if connection succeed, False otherwise """ return self._connection.is_connected() def set_color(self, rgb_color): """ Change bulb's color :param rgb_color: color as a list of 3 values between 0 and 255 """ self._connection.write_by_handle(HANDLE_CHANGE_COLOR, bytes(bytearray([MAGIC_CHANGE_COLOR] + list(rgb_color)))) def set_random_color(self): """ Change bulb's color with a random color """ self.set_color([random.randint(1, 255) for i in range(3)]) def turn_off(self): """ Turn off the light by setting color to black (rgb(0,0,0)) """ self.set_color([0, 0, 0]) def turn_on(self, brightness=1.0): """ Set white color on the light :param brightness: a float value between 0.0 and 1.0 defining the brightness """ self.set_color([int(255 * brightness) for i in range(3)])
def ReadFlowerCare(address): try: requester = GATTRequester(address) except: return 'error', 0, 0, 0, 0, 0 try: # Read battery and firmware version attribute data = requester.read_by_handle(0x0038)[0] battery, version = unpack('<B6s', data) version = filter(lambda x: x in string.printable, version) except: return 'error', 0, 0, 0, 0, 0 try: # Enable real-time data reading requester.write_by_handle(0x0033, str(bytearray([0xa0, 0x1f]))) except: return 'error', 0, 0, 0, 0, 0 try: # Read plant data data = requester.read_by_handle(0x0035)[0] except: return 'error', 0, 0, 0, 0, 0 try: temperature, sunlight, moisture, fertility = unpack( '<hxIBHxxxxxx', data) return version, battery, temperature, sunlight, moisture, fertility except: return 'error', 0, 0, 0, 0, 0
def __init__(self, addr=None, device='hci0', debug=False, **connect_kwargs): ''' @param addr (optional): MAC address of Pavlok device If not passed, will be discovered with DiscoveryService (requires root privileges) @param device (optional): host Bluetooth interface ('hci0' by default) @param debug (optional): debug logging (disabled by default) @param connect_kwargs: keyword arguments (security_level, channel_type, mtu, psm) to pass to GATTRequester.connect security_level: 'low' (default), 'medium', 'high' channel_type: 'public' (default), 'random' mtu: integer psm: integer ''' self._init_logging(debug) if not addr: addr = self._get_pavlok_mac_addr(device) assert addr, 'Could not find Pavlok device' GATTRequester.__init__(self, addr, False, device) #GATTRequester is an old-style class if connect_kwargs: self.logger.debug('Got keyword arguments for self.connect: %s', connect_kwargs) self.connect( wait=False, **connect_kwargs ) #Blocking connect() is better, but it would require root privileges self._wait_until_connected() characteristics = self.discover_characteristics() self.logger.debug('GATT characteristics: %s', characteristics) #Find matching value handles for service UUIDs self.handles = {name:filter(lambda e: e['uuid'] == uuid, characteristics)[0]['value_handle']\ for name, uuid in self.service_uuids.items()} self.logger.debug('GATT value handles: %s', self.handles) self.logger.debug('Hardware revision: %s, firmware revision: %s', self.hardware_revision, self.firmware_revision)
class AsyncReader(object): def __init__(self, address): self.requester = GATTRequester(address, False) self.response = NotifyMeYourValue() self.connect() self.request_data() self.loop() def connect(self): print("Connecting...", end=' ') sys.stdout.flush() self.requester.connect(True) print("OK!") def request_data(self): self.requester.read_by_handle_async(0x1, self.response) def loop(self): while not self.response.done: time.sleep(0.1)
def connect(self, device: str, interface: str = None, wait: bool = True, channel_type: str = 'public', security_level: str = 'low', psm: int = 0, mtu: int = 0, timeout: float = 10.0): """ Connect to a bluetooth LE device :param device: Device address to connect to :param interface: Bluetooth adapter name to use (default configured if None) :param wait: If True then wait for the connection to be established before returning (no timeout) :param channel_type: Channel type, usually 'public' or 'random' :param security_level: Security level - possible values: ['low', 'medium', 'high'] :param psm: PSM value (default: 0) :param mtu: MTU value (default: 0) :param timeout: Connection timeout if wait is not set (default: 10 seconds) """ from gattlib import GATTRequester req = self._req_by_addr.get(device) if req: if req.is_connected(): self.logger.info( 'Device {} is already connected'.format(device)) return self._req_by_addr[device] = None if not interface: interface = self.interface if interface: req = GATTRequester(device, False, interface) else: req = GATTRequester(device, False) self.logger.info('Connecting to {}'.format(device)) connect_start_time = time.time() req.connect(wait, channel_type, security_level, psm, mtu) if not wait: while not req.is_connected(): if time.time() - connect_start_time > timeout: raise TimeoutError( 'Connection to {} timed out'.format(device)) time.sleep(0.1) self.logger.info('Connected to {}'.format(device)) self._req_by_addr[device] = req
class PassiveDisconnect(object): def __init__(self, address): self.requester = GATTRequester(address, False) self.connect() self.wait_disconnection() def connect(self): print("Connecting...", end=' ') sys.stdout.flush() self.requester.connect(True) print("OK!") def wait_disconnection(self): status = "connected" if self.requester.is_connected() else "not connected" print("Checking current status: {}".format(status)) print("\nNow, force a hardware disconnect. To do so, please switch off,\n" "reboot or move away your device. Don't worry, I'll wait...") while self.requester.is_connected(): time.sleep(1) print("\nOK. Current state is disconnected. Congratulations ;)")
def __init__(self): service = DiscoveryService("hci0") devices = service.discover(2) for address, name in devices.items(): if name != '' and 'nemo-wedo2' in name: print(name) req = GATTRequester(address, True, "hci0") break if 'req' not in dir(): print('Connecting to wedo2.0 hub is failed!') os._exit(0) self.req = req
def smart_hub_connect(): service = DiscoveryService("hci0") devices = service.discover(2) for address, name in devices.items(): if name != '' and 'Smart Hub' in name: label['text'] = address global button_run, button_stop, button_disconnect, req button_connect['state'] = 'disabled' button_run['state'] = 'normal' button_stop['state'] = 'normal' button_disconnect['state'] = 'normal' button_up['state'] = 'normal' button_down['state'] = 'normal' req = GATTRequester(address, True, "hci0") break
def __init__(self, wakeup, pstream, *args): GATTRequester.__init__(self, *args) self.wakeup = wakeup self.s = pstream
def __init__(self, address): self.requester = GATTRequester(address, False) self.connect() self.wait_disconnection()
def __init__(self, address): self.requester = GATTRequester(address , False) self.connect() self.send_data()
from gattlib import GATTRequester req = GATTRequester("C9:E8:56:3B:4D:B1", False) req.connect(True, "random") req.is_connected() print(req.discover_primary()) req.disconnect()
from gattlib import GATTRequester import time # Send: 0x0035 for left # Send: 0x0039 for right # Send: 0x0029 for frequency req = GATTRequester("90:59:AF:14:08:E8") req.write_by_handle(0x0036, str(bytearray([1]))) time.sleep(1) req.write_by_handle(0x0039, str(bytearray([1])))
def __init__(self, mac_address): self.mac_address = mac_address self.req = GATTRequester(mac_address) print type(self.req)