def _tryQueryMbService(self, uuid):
conn = GATTRequester(uuid, False, self.devName)
try:
conn.connect(False, "random")
max_time = time.time() + 5
while not conn.is_connected():
if time.time() > max_time:
return False
time.sleep(0.5)
DEV_NAME_SERVICE_UUID = "00002a00-0000-1000-8000-00805f9b34fb" # 2A00, device name
try:
value = "".join(conn.read_by_uuid(DEV_NAME_SERVICE_UUID))
except RuntimeError as err:
msg = err.message.lower()
if "no attribute found":
return False
else:
raise
value = value.lower()
return ("mibp" in value or "mib-push" in value)
finally:
if conn.is_connected():
conn.disconnect()
while conn.is_connected():
time.sleep(0.5)
class Reader:
def __init__(self, address):
self.requester1 = GATTRequester("40:06:A0:97:74:A9", False)
self.requester2 = GATTRequester("40:06:A0:94:FE:F7", False)
self.connect()
self.send_data()
#self.request_data()
def connect(self):
print("Connecting...", end=" ")
sys.stdout.flush()
self.requester1.connect(True)
self.requester2.connect(True)
print("OK.")
def request_data(self):
data1 = self.requester1.read_by_uuid(
"00001800-0000-1000-8000-00805f9b34fb")[0]
data2 = self.requester2.read_by_uuid(
"00001800-0000-1000-8000-00805f9b34fb")[0]
try:
print("Device name:", data1.decode("utf-8"))
except AttributeError:
print("Device name:", data1)
def send_data(self):
#data = str(bytearray("TTWU"))
#print("Send Ok ,"+data)
print("sidong off")
self.requester1.write_by_handle(0x12, b'\x54\x52\x46\x68\x0D\x0A')
self.requester2.write_by_handle(0x12, b'\x54\x52\x46\x68\x0D\x0A')
#print("brake")
#self.requester1.write_by_handle(0x12, b'\x54\x53\x53\x5A\x0D\x0A')
#self.requester2.write_by_handle(0x12, b'\x54\x53\x53\x5A\x0D\x0A')
print("Sidong ON")
self.requester1.write_by_handle(0x12, b'\x54\x52\x4E\x60\x0D\x0A')
self.requester2.write_by_handle(0x12, b'\x54\x52\x4E\x60\x0D\x0A')
print("SPEED SLOW")
#self.requester1.write_by_handle(0x12, b'\x54\x57\x32\x77\x0D\x0A')
#self.requester2.write_by_handle(0x12, b'\x54\x57\x32\x77\x0D\x0A')
print("SPEED FULL")
self.requester1.write_by_handle(0x12, b'\x54\x57\x82\x27\x0D\x0A')
self.requester2.write_by_handle(0x12, b'\x54\x57\x82\x27\x0D\x0A')
class Toio(object):
HANDLER = {'motor': "TBU"}
DIRECTION = {'fwd': 1, 'bck': 2}
MOTOR = {'1st': 1, '2nd': 2}
SPEED_MAX = 100
def __init__(self, addr):
self.req = ""
if not addr:
return
self.req = GATTRequester(addr, False)
print("Connecting...: {}".format(addr))
self.req.connect(wait=True, channel_type="random")
print("Connected: {}".format(addr))
def request_data(self, uuid):
return self.req.read_by_uuid(uuid)[0]
def write_data(self, handler, data):
self.req.write_by_handle(handler, data)
def disconnect(self):
self.req.disconnect()
def is_connected(self):
if not self.req:
return False
return self.req.is_connected()
def _move(self, motor_1st_dir, motor_1st_speed, motor_2nd_dir, motor_2nd_speed, duration_sec):
self.write_data(self.HANDLER['motor'], str(
bytearray([2, self.MOTOR['1st'], motor_1st_dir, motor_1st_speed, self.MOTOR['2nd'], motor_2nd_dir, motor_2nd_speed, int(duration_sec * 100)])))
import time
time.sleep(duration_sec)
def straight(self):
self._move(self.DIRECTION['fwd'], self.SPEED_MAX, self.DIRECTION['fwd'], self.SPEED_MAX, 1)
def turn_left(self):
self._move(self.DIRECTION['fwd'], self.SPEED_MAX / 2, self.DIRECTION['fwd'], self.SPEED_MAX, 1)
def turn_right(self):
self._move(self.DIRECTION['fwd'], self.SPEED_MAX, self.DIRECTION['fwd'], self.SPEED_MAX / 2, 1)
def back(self):
self._move(self.DIRECTION['bck'], self.SPEED_MAX, self.DIRECTION['bck'], self.SPEED_MAX, 1)
def spin_turn_180(self):
self._move(self.DIRECTION['bck'], self.SPEED_MAX, self.DIRECTION['fwd'], self.SPEED_MAX, 0.5)
def spin_turn_360(self):
self._move(self.DIRECTION['bck'], self.SPEED_MAX, self.DIRECTION['fwd'], self.SPEED_MAX, 1)
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):
#for each in self.requester.discover_characteristics():
# print(each)
# print(self.requester.read_by_handle(each['handle']))
path = "../server/info_pipe"
if os.path.exists(path):
os.unlink(path)
#os.remove(path)
print("Removed old pipe")
print("Begin reading data: ")
while (True):
data = self.requester.read_by_uuid(
#"0x2902")
"0000aaaa-0000-1000-8000-00805f9b34fb")
#"0000181c-0000-1000-8000-00805f9b34fbC")
#"00002a00-0000-1000-8000-00805f9b34fb")
#print(data)
data = [ord(datum) for datum in data[0]]
try:
os.mkfifo(path)
except:
#print("pipe already exists")
pass
fifo = open(path, 'w')
#copy & add randomness to data to show how aggregation
data1 = ",".join(
[str(random.uniform(i - 1.5, i + 1.5)) for i in data[:]])
data2 = ",".join(
[str(random.uniform(i - 1.5, i + 1.5)) for i in data[:]])
data3 = ",".join(
[str(random.uniform(i - 1.5, i + 1.5)) for i in data[:]])
print(str(data1))
fifo.write(data1 + "\n" + data2 + "\n" + data3)
fifo.close()
'''
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_uuid("00002a00-0000-1000-8000-00805f9b34fb")[0]
print("Device name: " + data.decode("utf-8"))
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_uuid(
"00002a00-0000-1000-8000-00805f9b34fb")[0]
print("Device name: " + data.decode("utf-8"))
def get_serial(bluetooth_address_s):
global serial_map
if bluetooth_address_s in serial_map:
return serial_map[bluetooth_address_s]
macaddress = ':'.join([bluetooth_address_s[i: i+2] for i in range(0, len(bluetooth_address_s), 2)])
requester = GATTRequester(macaddress, False)
try:
requester.connect(True, channel_type="random")
data = requester.read_by_uuid("00002a25-0000-1000-8000-00805f9b34fb")
serial = data[0]
serial_map[bluetooth_address_s] = serial
requester.disconnect()
return serial
except:
import traceback
traceback.print_exc()
return None
class Reader(object):
def __init__(self, address):
self.requester = GATTRequester(address, False)
self.connect()
self.request_data()
def connect(self):
print("Connecting...")
sys.stdout.flush()
self.requester.connect(True)
print("OK!")
def request_data(self):
data = self.requester.read_by_uuid(
"0003cdd0-0000-1000-8000-00805f9b0131")[0]
try:
print("Device name: " + data.decode("utf-8"))
except AttributeError:
print("Device name: " + data)
class BluezBleInterface(BleInterface):
def __init__(self, *args, **kwargs):
super(BluezBleInterface, self).__init__(*args, **kwargs)
self._addr = kwargs.get('addr')
self._log.info("Started interface {0}.".format(self))
def __del__(self):
self._disconnect()
def _connect(self, addr):
self._log.info("BLE %s connecting ..." % addr)
self.requester = GATTRequester(addr, False)
self.requester.connect(True)
chars = self.requester.discover_characteristics()
self.characteristic = {}
for char in chars:
self.characteristic[char['uuid']] = char['value_handle']
self._log.info("BLE %s connected OK" % self._addr)
def _disconnect(self):
self.requester.disconnect()
def _read_uuid(self, reg, type='float'):
value = self.requester.read_by_uuid(reg)[0]
if type == 'float':
return struct.unpack('H', value)[0] * 1.0
elif type == 'string':
try:
value = value.decode("utf-8")
except AttributeError:
pass
return value
else:
return value
def _write_uuid(self, reg, value, type='float'):
if type == 'string':
value = struct.pack('B', value)
self.requester.write_by_handle(self.characteristic[reg], value)
class Reader(object):
def __init__(self, address):
self.requester = GATTRequester(address, False)
self.connect()
t = threading.Thread(name=address,target=self.periodical_request)
t.daemon = True
t.start()
def connect(self):
self.requester.connect(True,"random","medium",0,32)
print ("Connected")
def request_uuid(self):
self.uuid = self.requester.read_by_uuid("D6F8BDCC-3885-11E6-AC61-9E71128CAE77")[0]
print("uuid read:", self.uuid)
if len(self.uuid) < 37:
self.uuid = self.uuid + self.requester.read_by_uuid("D6F8BDCC-3885-11E6-AC61-9E71128CAE77")[0]
print("complete uuid:", self.uuid[0:35])
def periodical_request(self):
tracked_devices.append(threading.current_thread().getName())
try:
self.request_uuid()
except RuntimeError:
tracked_devices.remove(threading.current_thread().getName())
return
count = 0
while True:
self.request_data()
count = count + 1
print("Count:",count)
time.sleep(1)
def request_data(self):
if not self.requester.is_connected():
print("Reconnecting")
self.requester.disconnect()
try:
self.requester.connect(True,"random","medium",0,32)
except RuntimeError:
# End the thread bc cannot reconnect
if threading.current_thread().getName() in tracked_devices:
# should be in the tracked devices list
# remove when thread is going to end
tracked_devices.remove(threading.current_thread().getName())
else :
print("Error: thread should be tracked")
print("Encountered error when reconnecting. Now exit thread.")
sys.exit()
print("Reconnected")
try:
start_time = current_milli_time()
data = self.requester.read_by_uuid(
"16864516-21E0-11E6-B67B-9E71128CAE77")[0]
except RuntimeError as e:
print("RuntimeError", e)
self.requester.disconnect()
return
try:
d = decode_string_to_double(data)
print ("Device name:",self.uuid,"Device motion:", d)
if socket_open:
socket_connect.sendMotionAndUUID(d,self.uuid)
motion_manager.process_data(self.uuid[0:35], self.uuid[36],d)
except AttributeError:
print ("Device name: " + data)
