def do_connect(self, params):
try:
l = int(params)
except ValueError:
print "*** argument should be number"
return
except IndexError:
print "*** connect takes at least one parameter"
return
dev_id = l
if dev_id >= len(self.mibands.keys()):
print "*** device not in the device list"
return
if len(connected_devices.keys()) >= 5:
print(
"Can't connect to more than 5 devices at the same time, disconnect some"
)
else:
if ((args.mode == "db"
and mb2db.is_device_registered(mb2db.cnxn,
self.mibands.keys()[dev_id]))
or args.mode == "json" and self.mibands.keys()[dev_id]
in self.registered_devices):
if self.mibands.keys()[dev_id] in connected_devices.keys():
print("That MiBand2 is already connected")
else:
try:
addr = self.mibands.keys()[dev_id]
self.scd.tmp_devices[addr]["strikes"] = -9999
if not addr in self.devices_keys.keys():
self.devices_keys[addr] = random_key()
mb2 = MiBand2(addr,
self.devices_keys[addr],
initialize=False)
connected_devices[self.mibands.keys()[dev_id]] = mb2
if args.mode == "db":
alarms = mb2db.get_device_alarms(
mb2db.cnxn, mb2.addr)
mb2db.update_battery(mb2db.cnxn, mb2.addr,
mb2.battery_info['level'])
else:
if mb2.addr in self.devices_alarms.keys():
alarms = self.devices_alarms[mb2.addr]
else:
alarms = []
for a in alarms:
mb2.alarms += [
MiBand2Alarm(a["hour"],
a["minute"],
enabled=a["enabled"],
repetitionMask=a["repetition"])
]
except BTLEException as e:
print(
"There was a problem connecting to this MiBand2, try again later"
)
print e
else:
print(
"You have to register the MiBand2 before connecting to it")
def do_fetch_activity(item, cmd):
print "Fetching MiBand2 [%s] activity!" % item
if item not in connected_devices.keys():
try:
if not item in cmd.devices_keys.keys():
cmd.devices_keys[item] = random_key()
mb2 = MiBand2(addr, self.devices_keys[item], initialize=False)
connected_devices[item] = mb2
except BTLEException as e:
print("There was a problem connecting this MiBand2, try again later")
print e
try:
if args.mode == "db":
last_sync = mb2db.get_device_last_sync(mb2db.cnxn, item)
else:
last_sync = None
if item in cmd.devices_last_sync.keys():
last_sync = cmd.devices_last_sync[item]
if last_sync != None:
connected_devices[item].setLastSyncDate(last_sync)
connected_devices[item].send_alert(b'\x03')
connected_devices[item].fetch_activity_data()
connected_devices[item].send_alert(b'\x03')
if len(connected_devices[item].getActivityDataBuffer()) > 0:
print "Saving Data to DB..."
if args.mode == "db":
mb2db.write_activity_data(mb2db.cnxn, connected_devices[item])
else:
connected_devices[item].store_activity_data_file(base_route + '/localdata/activity_log/')
print "Finished fetching MiBand2 [%s] activity!" % item
except BTLEException as e:
print("There was a problem retrieving this MiBand2's activity, try again later")
print e
def do_fetch_activity(item):
print "Fetching MiBand2 [%s] activity!" % item
if item not in connected_devices.keys():
try:
mb2 = MiBand2(item, initialize=False)
connected_devices[item] = mb2
except BTLEException as e:
print(
"There was a problem connecting this MiBand2, try again later")
print e
try:
last_sync = mb2db.get_device_last_sync(cnxn_string, item)
if last_sync != None:
connected_devices[item].setLastSyncDate(last_sync)
connected_devices[item].send_alert(b'\x03')
connected_devices[item].fetch_activity_data()
connected_devices[item].send_alert(b'\x03')
if len(connected_devices[item].getActivityDataBuffer()) > 0:
print "Saving Data to DB..."
mb2db.write_activity_data(cnxn_string, connected_devices[item])
print "Finished fetching MiBand2 [%s] activity!" % item
except BTLEException as e:
print(
"There was a problem retrieving this MiBand2's activity, try again later"
)
print e
def devices():
if request.method == "GET":
dev_list = []
print(connected_devices)
mibands = copy.deepcopy(tmp_mibands)
for idx, mb in enumerate(mibands.keys()):
dev_id = mb2db.get_device_id(cnxn_string, mb)
dev_user = mb2db.get_device_user(cnxn_string, dev_id)
device = mb2db.get_device_by_id(cnxn_string, dev_id)
battery = -1
if device:
battery = device.bateria
username = (dev_user.nombre + " " +
dev_user.apellidos) if dev_user else "Unregistered"
dev_dict = {
"address": mb,
"signal": mibands[mibands.keys()[idx]].rssi,
"registered": False,
"connected": False,
"dev_id": dev_id,
"user_name": username,
"battery": battery,
"strikes": strikes[mibands[mibands.keys()[idx]].addr.upper()]
}
if mb2db.is_device_registered(cnxn_string, mb):
dev_dict["registered"] = True
if mb in connected_devices.keys():
dev_dict["connected"] = True
dev_list += [dev_dict]
print json.dumps(dev_list)
return json.dumps(dev_list)
elif request.method == "POST":
addr = request.form["address"].upper()
if mb2db.is_device_registered(cnxn_string, addr):
abort(403)
else:
try:
strikes[addr] = -9999
mb2 = MiBand2(addr, initialize=True)
mb2.cleanAlarms()
dev_id = mb2db.register_device(cnxn_string, mb2.addr)
mb2db.delete_all_alarms(cnxn_string, dev_id)
mb2db.update_battery(cnxn_string, mb2.addr,
mb2.battery_info['level'])
# Device stays connected after initialize, but we don't want that
mb2.disconnect()
strikes[addr] = 0
return json.dumps({"dev_id": dev_id, "registered": True})
except BTLEException as e:
print(
"There was a problem registering this MiBand2, try again later"
)
print e
abort(500)
except BTLEException.DISCONNECTED as d:
print("Device disconnected, removing from connected devices")
del connected_devices[addr]
del mb2
abort(500)
def main():
""" main func """
parser = argparse.ArgumentParser()
parser.add_argument('host', action='store', help='MAC of BT device')
parser.add_argument('-t',
action='store',
type=float,
default=3.0,
help='duration of each notification')
parser.add_argument('--init', action='store_true', default=False)
parser.add_argument('-n', '--notify', action='store_true', default=False)
parser.add_argument('-hrm', '--heart', action='store_true', default=False)
parser.add_argument('-act',
'--activity',
action='store_true',
default=False)
parser.add_argument(
'-sn',
'--since',
action='store',
type=str,
default="2018-04-06 00:00",
help=
'optional date to retrieve activity since, format "YYYY-MM-DD hh:mm"')
parser.add_argument('-de',
'--devevent',
action='store_true',
default=False)
arg = parser.parse_args(sys.argv[1:])
print('Connecting to ' + arg.host)
band = MiBand2(arg.host, initialize=arg.init)
if arg.notify:
print("Sending message notification...")
band.send_alert(b'\x01')
time.sleep(arg.t)
print("Sending phone notification...")
band.send_alert(b'\x02')
time.sleep(arg.t)
print("Turning off notifications...")
band.send_alert(b'\x00')
if arg.heart:
band.monitorHeartRate()
if arg.activity:
band.setLastSyncDate(arg.since)
band.fetch_activity_data()
if arg.devevent:
band.event_listen()
print("Disconnecting...")
band.disconnect()
del band
def main():
sc = Scanner()
devs = sc.scan(5)
if (len(devs) > 0):
mb2 = MiBand2(devs[0])
else:
exit()
mb2.authenticate()
mb2.setDelegate(ActivityDelegate(mb2))
mb2.req_battery()
print(mb2.battery_info)
def do_fetch_activity(item, silent_fetch):
print "Fetching MiBand [%s] activity!" % item
disconnect_after = False
if item not in connected_devices.keys():
try:
disconnect_after = True
if not item in devices_keys.keys():
key = DEFAULT_KEY
else:
key = devices_keys[item.upper()]
if model[item] == "mb2":
mb = MiBand2(item, key, initialize=False)
elif model[item] == "mb3":
mb = MiBand3(item, key, initialize=False)
connected_devices[item] = mb
except BTLEException as e:
print(
"There was a problem connecting this MiBand, try again later")
print e
if item in connected_devices.keys():
connected_devices[item].force_disconnect()
del connected_devices[item]
if item in connected_devices.keys():
try:
last_sync = mbdb.get_device_last_sync(cnxn_string, item)
if last_sync != None:
connected_devices[item].setLastSyncDate(last_sync)
if not silent_fetch:
connected_devices[item].send_alert(b'\x03')
connected_devices[item].fetch_activity_data()
if not silent_fetch:
connected_devices[item].send_alert(b'\x03')
if len(connected_devices[item].getActivityDataBuffer()) > 0:
print "Saving Data to DB..."
mbdb.write_activity_data(cnxn_string, connected_devices[item])
print "Finished fetching MiBand [%s] activity!" % item
if disconnect_after:
connected_devices[item].disconnect()
del connected_devices[item]
except BTLEException as e:
print(
"There was a problem retrieving this MiBand's activity, try again later"
)
print e
if item in connected_devices.keys():
connected_devices[item].force_disconnect()
del connected_devices[item]
def do_register(self, params):
try:
l = int(params)
except ValueError:
print "*** argument should be number"
return
except IndexError:
print "*** register takes at least one parameter"
return
dev_id = l
if dev_id >= len(self.mibands.keys()):
print "*** device not in the device list"
return
if ((args.mode == "db" and mbdb.is_device_registered(cnxn_string, self.mibands.keys()[dev_id]))
or args.mode == "json" and self.mibands.keys()[dev_id] in self.registered_devices):
print("That MiBand is already registered")
else:
mb = None
try:
addr = self.mibands.keys()[dev_id]
model = self.models[addr]
if not addr in self.devices_keys.keys():
self.devices_keys[addr] = random_key()
if model.upper() == "MB2":
mb = MiBand2(addr, self.devices_keys[addr], initialize=False)
elif model.upper() == "MB3":
mb = MiBand3(addr, self.devices_keys[addr], initialize=False)
mb.cleanAlarms()
if args.mode == "db":
dev_id = mbdb.get_device_id(cnxn_string, mb.addr)
mbdb.delete_all_alarms(cnxn_string, dev_id)
mbdb.register_device(cnxn_string, mb.addr)
mbdb.update_battery(cnxn_string, mb.addr, mb.battery_info['level'])
else:
self.registered_devices += [mb.addr]
# Device stays connected after initialize, but we don't want that
mb.disconnect()
except BTLEException as e:
print("There was a problem registering this MiBand, try again later")
print e
except KeyError as e:
print("Device was kicked out")
print e
def do_register(self, params):
try:
l = int(params)
except ValueError:
print "*** argument should be number"
return
except IndexError:
print "*** register takes at least one parameter"
return
dev_id = l
if dev_id >= len(self.mibands.keys()):
print "*** device not in the device list"
return
if ((args.mode == "db"
and mb2db.is_device_registered(mb2db.cnxn,
self.mibands.keys()[dev_id]))
or args.mode == "json"
and self.mibands.keys()[dev_id] in self.registered_devices):
print("That MiBand2 is already registered")
else:
mb2 = None
try:
addr = self.mibands.keys()[dev_id]
self.scd.tmp_devices[addr]["strikes"] = -9999
if not addr in self.devices_keys.keys():
self.devices_keys[addr] = random_key()
mb2 = MiBand2(addr, self.devices_keys[addr], initialize=False)
mb2.cleanAlarms()
if args.mode == "db":
mb2db.delete_all_alarms(mb2db.cnxn, mb2.addr)
mb2db.register_device(mb2db.cnxn, mb2.addr)
mb2db.update_battery(mb2db.cnxn, mb2.addr,
mb2.battery_info['level'])
else:
self.registered_devices += [mb2.addr]
# Device stays connected after initialize, but we don't want that
mb2.disconnect()
except BTLEException as e:
print(
"There was a problem registering this MiBand2, try again later"
)
print e
mb2.disconnect
def do_fetch_activity(item):
print "Fetching MiBand2 [%s] activity!" % item
try:
mb2 = MiBand2(item, initialize=False)
try:
if item in devices_last_sync.keys():
mb2.setLastSyncDate(devices_last_sync[item])
mb2.send_alert(b'\x01')
mb2.fetch_activity_data(base_dir + '/activity_log/')
mb2.send_alert(b'\x01')
print "Finished fetching MiBand2 [%s] activity!" % item
lastDate = str(mb2.lastSyncDate)
mb2.disconnect()
return lastDate
except BTLEException as e:
print("There was a problem retrieving this MiBand2's activity, try again later")
print e
except BTLEException as e:
print("There was a problem connecting this MiBand2, try again later")
print e
return None
def do_fetch_activity(item):
print "Fetching MiBand2 [%s] activity!" % item
if item not in connected_devices.keys():
try:
mb2 = MiBand2(item, initialize=False)
connected_devices[item] = mb2
except BTLEException as e:
print("There was a problem connecting this MiBand2, try again later")
print e
try:
if item in devices_last_sync.keys():
connected_devices[item].setLastSyncDate(devices_last_sync[item])
connected_devices[item].send_alert(b'\x01')
connected_devices[item].fetch_activity_data()
connected_devices[item].send_alert(b'\x01')
devices_last_sync[item] = str(connected_devices[item].lastSyncDate)
print "Finished fetching MiBand2 [%s] activity!" % item
except BTLEException as e:
print("There was a problem retrieving this MiBand2's activity, try again later")
print e
finally:
connected_devices[item].disconnect()
del connected_devices[item]
def HiloCorazon():
print('Connecting')
band = MiBand2('FA:01:FB:63:6A:75')
band.setSecurityLevel(level="medium")
band.authenticate()
band.init_after_auth()
print("Cont. HRM start")
band.hrmStopContinuous()
band.hrmStartContinuous()
global bienestar
musica = reproducirPulso(0)
while True:
while bienestar:
band.char_hrm_ctrl.write(b'\x16', True)
band.waitForNotifications(1.0)
musica.reproducirMusica()
print("Disconnecting...")
band.disconnect()
del band
def device(dev_id):
row = mbdb.get_device_by_id(cnxn_string, dev_id)
if row:
if request.method == "GET":
connected = True if row.mac in connected_devices else False
signal = 0
mibands = copy.deepcopy(tmp_mibands)
if row.mac in mibands.keys():
signal = mibands[row.mac].rssi
dev_user = mbdb.get_device_user(cnxn_string, dev_id)
username = (dev_user.nombre + " " +
dev_user.apellidos) if dev_user else "Unregistered"
detail_dict = {
"dev_id": row.dispositivoId,
"battery": row.bateria,
"registered": row.registrado,
"address": row.mac,
"connected": connected,
"signal": signal,
"visible": (signal < 0),
"model": row.tipoDispositivo.upper(),
"user_name": username,
"reputation": reputation[row.mac.upper()]
}
return json.dumps(detail_dict)
elif request.method == "PUT":
if mbdb.is_device_registered(cnxn_string, row.mac):
action = request.form.get("action")
if action == "connect" and row.mac not in connected_devices.keys(
):
try:
reputation[row.mac.upper()] = 100
if not row.mac in devices_keys.keys():
key = DEFAULT_KEY
else:
key = devices_keys[row.mac.upper()]
if model[row.mac.upper()] == "mb2":
mb = MiBand2(
row.mac.upper(),
key,
initialize=False,
)
elif model[row.mac.upper()] == "mb3":
mb = MiBand3(
row.mac.upper(),
key,
initialize=False,
)
connected_devices[row.mac] = mb
alarms = mbdb.get_device_alarms(cnxn_string, mb.addr)
mbdb.update_battery(cnxn_string, mb.addr,
mb.battery_info['level'])
for a in alarms:
mb.alarms += [
MiBandAlarm(a["hour"],
a["minute"],
enabled=a["enabled"],
repetitionMask=a["repetition"])
]
reputation[row.mac.upper()] = 50
return json.dumps({
"connected": True,
"dev_id": row.dispositivoId
}), 200
except BTLEException as e:
reputation[row.mac.upper()] = 50
print(
"There was a problem (dis)connecting to this MiBand, try again later"
)
print e
abort(500)
except BTLEException.DISCONNECTED as d:
reputation[row.mac.upper()] = 50
print(
"Device disconnected, removing from connected devices"
)
del connected_devices[row.mac]
del mb
abort(500)
elif action == "disconnect" and row.mac in connected_devices.keys(
):
try:
mb = connected_devices[row.mac]
mb.disconnect()
mb.force_disconnect()
del connected_devices[row.mac]
del mb
print("MiBand disconnected!")
return json.dumps({
"connected": False,
"dev_id": row.dispositivoId
}), 200
except BTLEException as e:
print(
"There was a problem disconnecting this MiBand, try again later"
)
print e
abort(500)
except BTLEException.DISCONNECTED as d:
print(
"Device disconnected, removing from connected devices"
)
del connected_devices[row.mac]
del mb
abort(500)
elif action == "alert" and row.mac in connected_devices.keys():
try:
print("Alerting MB2 " + row.mac)
mb = connected_devices[row.mac]
if request.args.get('notification') == "message":
mb.send_alert(b'\x01')
elif request.args.get('notification') == "call":
mb.send_alert(b'\x02')
elif request.args.get('notification') == "vibrate":
mb.send_alert(b'\x03')
elif request.args.get('notification') == "stop":
mb.send_alert(b'\x00')
else:
mb.send_alert(b'\x03')
return json.dumps({
"alerting": True,
"dev_id": row.dispositivoId
}), 200
except BTLEException as e:
print(
"There was a problem alerting this MiBand, try again later"
)
del connected_devices[row.mac]
print e
abort(500)
except BTLEException.DISCONNECTED as d:
print(
"Device disconnected, removing from connected devices"
)
del connected_devices[row.mac]
del mb
abort(500)
elif request.method == "DELETE":
# Just Unregister MiBand
if mbdb.is_device_registered(cnxn_string, row.mac):
if not row.mac in connected_devices.keys():
try:
dev_id = mbdb.get_device_id(cnxn_string, row.mac)
mbdb.unregister_device(cnxn_string, dev_id)
mbdb.delete_all_alarms(cnxn_string, dev_id)
del devices_keys[row.mac.upper()]
print("MiBand unregistered!")
save_keys(devices_keys)
return json.dumps({
"registered": False,
"dev_id": row.dispositivoId
}), 200
except BTLEException as e:
print(
"There was a problem unregistering this MiBand, try again later"
)
print e
abort(500)
except BTLEException.DISCONNECTED as d:
print(
"Device disconnected, removing from connected devices"
)
if row.mac in connected_devices.keys():
connected_devices[row.mac].force_disconnect()
del connected_devices[row.mac]
abort(500)
abort(403)
else:
abort(404)
def devices():
if request.method == "GET":
dev_list = []
mibands = copy.deepcopy(tmp_mibands)
for idx, mb in enumerate(mibands.keys()):
dev_id = mbdb.get_device_id(cnxn_string, mb)
dev_user = mbdb.get_device_user(cnxn_string, dev_id)
device = mbdb.get_device_by_id(cnxn_string, dev_id)
battery = -1
if device:
battery = device.bateria
username = (dev_user.nombre + " " +
dev_user.apellidos) if dev_user else "Unregistered"
dev_dict = {
"address": mb,
"signal": mibands[mibands.keys()[idx]].rssi,
"registered": False,
"connected": False,
"dev_id": dev_id,
"model":
model[mibands[mibands.keys()[idx]].addr.upper()].upper(),
"user_name": username,
"battery": battery,
"reputation":
reputation[mibands[mibands.keys()[idx]].addr.upper()]
}
if mbdb.is_device_registered(cnxn_string, mb):
dev_dict["registered"] = True
if mb in connected_devices.keys():
dev_dict["connected"] = True
dev_list += [dev_dict]
return json.dumps(dev_list)
elif request.method == "POST":
addr = request.form["address"].upper()
if mbdb.is_device_registered(cnxn_string, addr):
abort(403)
else:
try:
reputation[addr] = 100
if not addr in devices_keys.keys():
devices_keys[addr] = random_key()
if model[addr] == "mb2":
mb = MiBand2(addr, devices_keys[addr], initialize=False)
elif model[addr] == "mb3":
mb = MiBand3(addr, devices_keys[addr], initialize=False)
devices_keys[addr] = mb.key
connected_devices[addr] = mb
save_keys(devices_keys)
mb.cleanAlarms()
dev_id = mbdb.register_device(cnxn_string, mb.addr,
mb.get_model())
mbdb.delete_all_alarms(cnxn_string, dev_id)
mbdb.update_battery(cnxn_string, mb.addr,
mb.battery_info['level'])
# Device stays connected after initialize, but we don't want that
del connected_devices[addr]
mb.disconnect()
reputation[addr] = 50
return json.dumps({"dev_id": dev_id, "registered": True})
except BTLEException as e:
print(
"There was a problem registering this MiBand, try again later"
)
print e
if addr in connected_devices.keys():
connected_devices[addr].force_disconnect()
del connected_devices[addr]
abort(500)
except BTLEException.DISCONNECTED as d:
print("Device disconnected, removing from connected devices")
print e
if addr in connected_devices.keys():
connected_devices[addr].force_disconnect()
del connected_devices[addr]
abort(500)
import sys
import binascii
sys.path.append('./lib')
from miband2 import MiBand2
mb2 = MiBand2("fc:5a:18:28:15:53")
for svc in mb2.services:
print 'SERV: {0}\tUUID: {1}'.format(svc.uuid.getCommonName(), svc.uuid)
for c in svc.getCharacteristics():
if c.supportsRead():
print '\tCHAR: {0}\t({1}) // HANDLE: {2} // VALUE: {3}'.format(
c.uuid.getCommonName(), c.uuid, c.getHandle(),
binascii.hexlify(c.read()))
else:
print '\tCHAR: {0}\t({1}) // HANDLE: {2} // PROPS: {3}'.format(
c.uuid.getCommonName(), c.uuid, c.getHandle(),
c.propertiesToString())
print '\n'
from bluepy.btle import Scanner, DefaultDelegate
from miband2 import MiBand2, ActivityDelegate
# Script to initalize all the MB2s in range
print "Scanning for nearby MiBands2..."
sc = Scanner()
devs = sc.scan(5)
print "Found {0} devices! Initializing...".format(len(devs))
mibands = []
for d in devs:
mb = MiBand2(d)
mibands += [mb]
mb.initialize()
mb.disconnect()
def device(dev_id):
row = mb2db.get_device_by_id(cnxn_string, dev_id)
if row:
if request.method == "GET":
connected = True if row.mac in connected_devices else False
signal = 0
mibands = copy.deepcopy(tmp_mibands)
if row.mac in mibands.keys():
signal = mibands[row.mac].rssi
dev_user = mb2db.get_device_user(cnxn_string, dev_id)
username = (dev_user.nombre + " " +
dev_user.apellidos) if dev_user else "Unregistered"
detail_dict = {
"dev_id": row.dispositivoId,
"battery": row.bateria,
"registered": row.registrado,
"address": row.mac,
"connected": connected,
"signal": signal,
"visible": (signal < 0),
"user_name": username
}
return json.dumps(detail_dict)
elif request.method == "PUT":
if mb2db.is_device_registered(cnxn_string, row.mac):
action = request.form.get("action")
strikes[row.mac] = -9999
if action == "connect" and row.mac not in connected_devices.keys(
):
try:
mb2 = MiBand2(row.mac, initialize=False)
connected_devices[row.mac] = mb2
alarms = mb2db.get_device_alarms(cnxn_string, mb2.addr)
mb2db.update_battery(cnxn_string, mb2.addr,
mb2.battery_info['level'])
for a in alarms:
mb2.alarms += [
MiBand2Alarm(a["hour"],
a["minute"],
enabled=a["enabled"],
repetitionMask=a["repetition"])
]
return json.dumps({
"connected": True,
"dev_id": row.dispositivoId
}), 200
except BTLEException as e:
print(
"There was a problem (dis)connecting to this MiBand2, try again later"
)
print e
abort(500)
except BTLEException.DISCONNECTED as d:
print(
"Device disconnected, removing from connected devices"
)
del connected_devices[row.mac]
del mb2
abort(500)
elif action == "disconnect" and row.mac in connected_devices.keys(
):
try:
mb2 = connected_devices[row.mac]
mb2.disconnect()
del connected_devices[row.mac]
del mb2
print("MiBand2 disconnected!")
return json.dumps({
"connected": False,
"dev_id": row.dispositivoId
}), 200
except BTLEException as e:
print(
"There was a problem disconnecting this MiBand2, try again later"
)
print e
abort(500)
except BTLEException.DISCONNECTED as d:
print(
"Device disconnected, removing from connected devices"
)
del connected_devices[row.mac]
del mb2
abort(500)
elif request.method == "DELETE":
# Just Unregister MiBand2
if mb2db.is_device_registered(cnxn_string, row.mac):
if not row.mac in connected_devices.keys():
try:
dev_id = mb2db.get_device_id(cnxn_string, row.mac)
mb2db.unregister_device(cnxn_string, dev_id)
mb2db.delete_all_alarms(cnxn_string, dev_id)
print("MiBand2 unregistered!")
return json.dumps({
"registered": False,
"dev_id": row.dispositivoId
}), 200
except BTLEException as e:
print(
"There was a problem unregistering this MiBand2, try again later"
)
print e
abort(500)
except BTLEException.DISCONNECTED as d:
print(
"Device disconnected, removing from connected devices"
)
del connected_devices[row.mac]
del mb2
abort(500)
abort(403)
else:
abort(404)
def main():
sc = Scanner()
scd = MiBand2ScanDelegate()
sc.withDelegate(scd)
scan_thread = threading.Thread(target=scan_miband2, args=(sc,))
scan_thread.start()
for i in range(max_connections):
t = threading.Thread(target=worker)
t.daemon = True
t.start()
while True:
try:
s = raw_input('> ')
except:
break
try:
command = s.strip().lower()
if command == "exit":
scan_thread.do_scan = False
scan_thread.join()
print ("Disconnecting from %s devices" % len(connected_devices.values()))
for con in connected_devices.values():
con.disconnect()
print("Saving changes to Registered Devices storage")
save_registered(registered_devices, devices_last_sync)
break
elif command == "save":
print("Saving changes to Registered Devices storage")
save_registered(registered_devices, devices_last_sync)
elif command == "devices":
mibands = scd.tmp_devices
for idx,mb in enumerate(mibands.keys()):
str = "[%s] Mi Band 2 (%s) %sdB " % (idx,mb,mibands[mibands.keys()[idx]].rssi)
if mb in registered_devices:
str += "[R]"
if mb in connected_devices:
str += "[C]"
print str
elif "alert" in command:
arg = re.search("\w+\s+(\d+)\s+(\d+)", command)
if arg != None and len(arg.groups()) == 2:
dev_id = int(arg.groups()[0])
alert_int = int(arg.groups()[1])
if mibands.keys()[dev_id] in registered_devices:
if mibands.keys()[dev_id] in connected_devices.keys():
try:
mb2 = connected_devices[mibands.keys()[dev_id]]
data = struct.pack('B', alert_int)
mb2.send_alert(data)
print "Sending Notification: " + binascii.hexlify(data)
except BTLEException:
print("There was a problem alerting this MiBand2, try again later")
else:
print("That MiBand2 is not connected!")
else:
print("That MiBand2 is not registered")
else:
print("'alert' takes two parameters")
elif "unregister" in command:
arg = re.search("\w+\s+(\d+)", command)
if arg != None and len(arg.groups()) == 1:
dev_id = int(arg.groups()[0])
if mibands.keys()[dev_id] in registered_devices:
if not mibands.keys()[dev_id] in connected_devices.values():
try:
registered_devices.remove(mibands.keys()[dev_id])
print("MiBand2 unregistered!")
except BTLEException:
print("There was a problem unregistering this MiBand2, try again later")
else:
print("Disconnect the miBand2 first!")
else:
print("That MiBand2 is not registered")
else:
print("'unregister' takes only one parameter")
elif "register" in command:
arg = re.search("\w+\s+(\d+)", command)
if arg != None and len(arg.groups()) == 1:
dev_id = int(arg.groups()[0])
if mibands.keys()[dev_id] in registered_devices:
print("That MiBand2 is already registered")
else:
try:
mb2 = MiBand2(mibands.keys()[dev_id], initialize=True)
registered_devices.append(mibands.keys()[dev_id])
except BTLEException as e:
print("There was a problem disconnecting this MiBand2, try again later")
print e
else:
print("'register' takes only one parameter")
elif "disconnect" in command:
arg = re.search("\w+\s+(\d+)", command)
if arg != None and len(arg.groups()) == 1:
dev_id = int(arg.groups()[0])
if len(connected_devices.keys()) >= max_connections:
print("Can't connect to more than 5 devices at the same time, disconnect some")
else:
if mibands.keys()[dev_id] in connected_devices.keys():
try:
mb2 = connected_devices[mibands.keys()[dev_id]]
mb2.disconnect()
del connected_devices[mibands.keys()[dev_id]]
del mb2
print ("MiBand2 disconnected!")
except BTLEException as e:
print("There was a problem disconnecting this MiBand2, try again later")
print e
else:
print("That MiBand2 isn't connected!")
else:
print("'connect' takes only one parameter")
elif "connect" in command:
arg = re.search("\w+\s+(\d+)", command)
if arg != None and len(arg.groups()) == 1:
dev_id = int(arg.groups()[0])
if len(connected_devices.keys()) >= 5:
print("Can't connect to more than 5 devices at the same time, disconnect some")
else:
if mibands.keys()[dev_id] in registered_devices:
if mibands.keys()[dev_id] in connected_devices.keys():
print("That MiBand2 is already connected")
else:
try:
mb2 = MiBand2(mibands.keys()[dev_id], initialize=False)
connected_devices[mibands.keys()[dev_id]] = mb2
except BTLEException as e:
print("There was a problem connecting to this MiBand2, try again later")
print e
else:
print("You have to register the MiBand2 before connecting to it")
else:
print("'connect' takes only one parameter")
elif "alarms" in command:
pass
# TODO: load JSON alarms into device representation
# let the user view, queue, toggle and toggle days of each alarm
# save and persist alarms in JSON form, key should be mac
# and elements arrays of alarm parameters (hour, min, enabledness and daymasks)
elif "activity" in command:
arg = re.search("\w+\s+(\w+)", command)
if arg != None and len(arg.groups()) == 1:
if arg.groups()[0] == 'all':
print("Fetching all registered and in range Miband2's activity data")
# Check that the registered device is present on the scanned mibands list
for item in filter(lambda x: x in registered_devices, mibands.keys()):
q.put(item)
else:
dev_id = int(arg.groups()[0])
if mibands.keys()[dev_id] in registered_devices:
q.put(mibands.keys()[dev_id])
else:
print("MiBand2 should be registered before fetching activity data")
else:
print("'activity' takes only one parameter")
elif command == '':
pass
else:
print ("Unknown command %s, try using 'help'" % command)
except OSError:
print 'Invalid command'
# This script extracts the services and characteristics from a MiBand2 and stores
# them on a local file so they can be loaded from a file and save time
# This file is provided in the repo, but you might want to update it
from miband2 import MiBand2
import json
ADDR = "00:11:22:33:44:55"
mb2 = MiBand2(ADDR, initialize=true)
svc_export = {}
for svc in mb2.svcs:
svc_export[str(svc.uuid)] = {
"hndStart": svc.hndStart,
"hndEnd": svc.hndEnd,
"chars": {}
}
for c in svc.getCharacteristics():
svc_export[str(svc.uuid)]["chars"][str(c.uuid)] = {
"handle": c.handle,
"valHandle": c.valHandle,
"properties": c.properties,
"descs": {}
}
for d in c.getDescriptors():
svc_export[str(svc.uuid)]["chars"][str(c.uuid)]["descs"][str(
d.uuid)] = {
"handle": d.handle
}
