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 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)
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()
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!")
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("")
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)
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 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])))
def __init__(self, address):
self.requester = GATTRequester(address, False)
self.response = GATTResponse()
self.connect()
self.request_data()
self.wait_response()
def __init__(self, address):
self.requester = GATTRequester(address, False)
self.connect()
self.check_status()
self.disconnect()
self.check_status()
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 __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(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 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)
