def do_reluser(self, params):
if args.mode == "db":
try:
l = params.split()
dev_id = int(l[0])
user_id = int(l[1])
except ValueError:
print "*** argument should be number"
return
except IndexError:
print "*** reluser takes at least one parameter"
return
if dev_id >= len(self.mibands.keys()):
print "*** device not in the device list"
return
udata = mbdb.get_user_data(cnxn_string, user_id)
if udata:
if mbdb.is_device_registered(cnxn_string, self.mibands.keys()[dev_id]):
if self.mibands.keys()[dev_id] in connected_devices.keys():
mb = connected_devices[self.mibands.keys()[dev_id]]
if mbdb.release_device_user(cnxn_string, mb.addr, user_id):
print "MiBand Released from user"
else:
print "There was a problem releasing this MiBand"
else:
print("MiBand should be connected before releasing user data")
else:
print("MiBand should be registered before releasing user data")
else:
print("*** user with id %s doesn't exist" % user_id)
else:
# TODO: If storage, release properly
print("This operation is only available for DB mode")
def do_unregister(self, params):
try:
l = int(params)
except ValueError:
print "*** argument should be number"
return
except IndexError:
print "*** unregister 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):
if not self.mibands.keys()[dev_id] in connected_devices.values():
try:
if args.mode == "db":
mbdb.unregister_device(cnxn_string, self.mibands.keys()[dev_id])
mbdb.delete_all_alarms(cnxn_string, self.mibands.keys()[dev_id])
else:
self.registered_devices.remove(self.mibands.keys()[dev_id])
del self.devices_keys[self.mibands.keys()[dev_id]]
print("MiBand unregistered!")
except BTLEException:
print("There was a problem unregistering this MiBand, try again later")
else:
print("Disconnect the miBand2 first!")
else:
print("That MiBand is not registered")
def do_alert(self, params):
l = params.split()
if len(l)!=2:
print "*** invalid number of arguments"
return
try:
l = [int(i) for i in l]
except ValueError:
print "*** arguments should be numbers"
return
except IndexError:
print "*** alert takes at least one parameter"
return
dev_id = int(l[0])
if dev_id >= len(self.mibands.keys()):
print "*** device not in the device list"
return
alert_int = int(l[1])
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):
if self.mibands.keys()[dev_id] in connected_devices.keys():
try:
mb = connected_devices[self.mibands.keys()[dev_id]]
data = struct.pack('B', alert_int)
mb.send_alert(data)
print "Sending Notification: " + binascii.hexlify(data)
except BTLEException:
print("There was a problem alerting this MiBand, try again later")
else:
print("That MiBand is not connected!")
else:
print("That MiBand is not registered")
def do_devices(self, line):
tmp_mibands = copy.deepcopy(self.scd.tmp_devices)
self.mibands = {k: v["device"] for k, v in tmp_mibands.items()}
self.models = {k: v["model"] for k, v in tmp_mibands.items()}
tmp_strikes = {k: v["strikes"] for k, v in tmp_mibands.items()}
for idx,mb in enumerate(self.mibands.keys()):
name = "Someone"
uid = 0
udata = None
if args.mode == "db":
devid = mbdb.get_device_id(cnxn_string, mb.upper())
devuser = mbdb.get_device_user(cnxn_string, devid)
if devuser != -1:
udata = mbdb.get_user_data(cnxn_string,devuser)
else:
udata = None
else:
# TODO: User Data on local storage???
pass
if udata:
name = udata["alias"]
uid = udata["id"]
model = self.models[self.mibands.keys()[idx]].upper()
str = "[%s]%10s's %s <U:%05d> (%s) %sdB S:%s " % (idx, name, model, uid, mb, self.mibands[self.mibands.keys()[idx]].rssi, "X"*tmp_strikes[self.mibands.keys()[idx]])
if (args.mode == "db" and mbdb.is_device_registered(cnxn_string, mb)) or (args.mode == "json" and mb in self.registered_devices):
str += "[R]"
if mb in connected_devices:
mb_dev = connected_devices[mb]
if args.mode == "db":
mbdb.update_battery(cnxn_string, mb_dev.addr, mb_dev.battery_info['level'])
str += "[C] [B:{0:03d}%]".format(mb.battery_info["level"])
print str
def do_setuser(self, params):
try:
l = params.split()
dev_id = int(l[0])
if args.mode == "db":
user_id = int(l[1])
else:
# TODO: Not persisted
user_alias = l[1]
if l[2] == "M":
user_gender = 0
elif l[2] == "F":
user_gender = 1
else:
user_gender = 2
user_bd_year = int(l[3])
user_bd_month = int(l[4])
user_bd_day = 0
user_weight = float(l[5])
user_height = int(l[6])
position = None
if l[2] == "left":
position = (0, "left")
elif l[2] == "right":
position = (1, "right")
else:
print("*** only left and right supported")
return
except ValueError:
print "*** argument should be number"
return
except IndexError:
print "*** setuser takes at least one parameter"
return
if dev_id >= len(self.mibands.keys()):
print "*** device not in the device list"
return
if args.mode == "db":
udata = mbdb.get_user_data(cnxn_string, user_id)
if udata or args.mode == "json":
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):
if self.mibands.keys()[dev_id] in connected_devices.keys():
mb = connected_devices[self.mibands.keys()[dev_id]]
if args.mode == "db":
if mbdb.set_device_user(cnxn_string, mb.addr, user_id, position[0]):
mb.setUserInfo(udata["alias"], udata["sex"], udata["height"], udata["weight"], udata["birth"])
else:
mb.setUserInfo(user_alias, user_gender, user_height, user_weight, (user_bd_year, user_bd_month, user_bd_day))
mb.setWearLocation(position[1])
else:
print("MiBand should be connected before setting user data")
else:
print("MiBand should be registered before setting user data")
else:
print("*** user with id %s doesn't exist" % user_id)
def configure_miband(self, dev_id, preset):
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):
if self.mibands.keys()[dev_id] in connected_devices.keys():
try:
mb = connected_devices[self.mibands.keys()[dev_id]]
print("Configuring MiBand to [%s] presets" % preset)
if config.has_option(preset, "MonitorHRSleep"):
mb.monitorHeartRateSleep(config.getint(preset, "MonitorHRSleep"))
if config.has_option(preset, "MonitorHRInterval"):
mb.setMonitorHeartRateInterval(config.getint(preset, "MonitorHRInterval"))
if config.has_option(preset, "DisplayTimeFormat"):
mb.setDisplayTimeFormat(config.get(preset, "DisplayTimeFormat"))
if config.has_option(preset, "DisplayTimeHours"):
mb.setDisplayTimeHours(config.getint(preset, "DisplayTimeHours"))
if config.has_option(preset, "DistanceUnit"):
mb.setDistanceUnit(config.get(preset, "DistanceUnit"))
if config.has_option(preset, "LiftWristActivate"):
mb.setLiftWristToActivate(config.getint(preset, "LiftWristActivate"))
if config.has_option(preset, "RotateWristSwitch"):
mb.setRotateWristToSwitchInfo(config.getint(preset, "RotateWristSwitch"))
if config.has_option(preset, "DisplayItems"):
disp = [x.strip() for x in config.get(preset, 'DisplayItems').split(',')]
steps = True if 'steps' in disp else False
distance = True if 'distance' in disp else False
calories = True if 'calories' in disp else False
heartrate = True if 'heartrate' in disp else False
battery = True if 'battery' in disp else False
mb.setDisplayItems(steps=steps, distance=distance, calories=calories, heartrate=heartrate, battery=battery)
if config.has_option(preset, "DoNotDisturb"):
enableLift = config.getint(preset, "DoNotDisturbLift") if config.has_option(preset, "DoNotDisturbLift") else 1
mb.setDoNotDisturb(config.get(preset, "DoNotDisturb"), enableLift=enableLift)
if config.has_option(preset, "InactivityWarnings"):
start = config.getint(preset, "InactivityWarningsStart") if config.has_option(preset, "InactivityWarningsStart") else 8
end = config.getint(preset, "InactivityWarningsEnd") if config.has_option(preset, "InactivityWarningsEnd") else 19
threshold = config.getint(preset, "InactivityWarningsThresholdHours") if config.has_option(preset, "InactivityWarningsThresholdHours") else 1
mb.setInactivityWarnings(config.getint(preset, "InactivityWarnings"), threshold=threshold*60, start=(start, 0), end=(end, 0))
if config.has_option(preset, "DisplayCaller"):
mb.setDisplayCaller(config.getint(preset, "DisplayCaller"))
except BTLEException as e:
print("There was a problem configuring this MiBand, try again later")
print e
else:
print("That MiBand is not connected, please connect it before configuring.")
else:
print("That MiBand is not registered, please register it before configuring.")
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 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):
if self.mibands.keys()[dev_id] in connected_devices.keys():
print("That MiBand is already connected")
else:
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)
connected_devices[self.mibands.keys()[dev_id]] = mb
if args.mode == "db":
alarms = mbdb.get_device_alarms(cnxn_string, mb.addr)
mbdb.update_battery(cnxn_string, mb.addr, mb.battery_info['level'])
else:
if mb.addr in self.devices_alarms.keys():
alarms = self.devices_alarms[mb.addr]
else:
alarms = []
for a in alarms:
mb.alarms += [MiBandAlarm(a["hour"], a["minute"], enabled=a["enabled"], repetitionMask=a["repetition"])]
except BTLEException as e:
print("There was a problem connecting to this MiBand, try again later")
print e
else:
print("You have to register the MiBand before connecting to it")
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_activity(self, params):
try:
l = int(params)
except ValueError:
print "*** argument should be number"
return
except IndexError:
print "*** activity 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):
if self.mibands.keys()[dev_id] in connected_devices.keys():
q.put(self.mibands.keys()[dev_id])
q.join()
else:
print("MiBand should be connected before fetching activity data")
else:
print("MiBand should be registered before fetching activity data")
def do_reboot(self, params):
try:
dev_id = int(params)
except ValueError:
print "*** arguments should be numbers"
return
except IndexError:
print "*** alert takes at least one parameter"
return
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)):
if self.mibands.keys()[dev_id] in connected_devices.keys():
try:
mb = connected_devices[self.mibands.keys()[dev_id]]
mb.reboot()
except BTLEException:
print("There was a problem rebooting this MiBand, try again later")
else:
print("That MiBand is not connected!")
else:
print("That MiBand is not registered")
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)
def scan_miband2(scanner, scanthresh):
print("Scanning!")
scanner.clear()
scanner.start()
t = threading.currentThread()
while getattr(t, "do_scan", True):
old_mibands = copy.deepcopy(tmp_mibands)
scanner.process(2)
for d in old_mibands.keys():
if d in connected_devices.keys():
reputation[d.upper()] = 50
if d in tmp_mibands.keys() and (d not in connected_devices.keys()):
new_signal = tmp_mibands[d.upper()].rssi
signal_diff = (old_mibands[d.upper()].rssi -
tmp_mibands[d.upper()].rssi)
proximity_factor = 1
if new_signal < scanthresh:
# If the device is away positive reputation increases slowly
proximity_factor = 0.5
elif new_signal > (scanthresh + 2 * (scanthresh / 3)):
# Pretty close
proximity_factor = 1.5
elif new_signal > (scanthresh + (scanthresh / 3)):
# Mid range
proximity_factor = 1.25
elif new_signal > (scanthresh):
# Away but ok
proximity_factor = 1
if signal_diff == 0:
# If stagnant, reputation decreases drastically
reputation[d.upper()] -= 10
elif signal_diff in range(-5, 6):
# If there is little variation, reputation increases
reputation[d.upper()] += 10 * proximity_factor
elif signal_diff < -5:
# If there is a VERY big negative variation, reputation decreases drastically
reputation[d.upper()] -= 10
elif signal_diff > 5:
# If there is a big positive variation, reputation increases a bit
reputation[d.upper()] += 5 * proximity_factor
if reputation[d.upper()] >= 100:
reputation[d.upper()] = 100
if reputation[d.upper()] <= 0:
reputation[d.upper()] = 0
if reputation[d.upper()] >= 90 and autofetch:
if (mbdb.is_device_registered(cnxn_string, d.upper())):
last_sync = mbdb.get_device_last_sync(
cnxn_string, d.upper())
timediff = None
if last_sync != None:
timediff = (datetime.datetime.now() - last_sync)
if timediff == None or timediff.total_seconds(
) > autofetch_cooldown:
q.put((
d.upper(),
True,
))
if reputation[d.upper()] <= 10:
del tmp_mibands[d.upper()]
del model[d.upper()]
if d.upper() in mibands.keys():
mibands[d.upper()].force_disconnect()
q.join()
print("Stopped scanning...")
scanner.stop()
def do_alarms(self, params):
l = params.split()
try:
dev_id = int(l[0])
command = "list"
if len(l) > 1:
command = l[1]
except ValueError:
print "*** argument 1 should be number"
return
except IndexError:
print "*** alarms takes at least one parameter"
return
if command not in ['list', 'queue', 'set', 'toggle', 'toggleday', 'delete', 'clear']:
print "*** invalid alarm command, see help"
return
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):
if self.mibands.keys()[dev_id] in connected_devices.keys():
mb = connected_devices[self.mibands.keys()[dev_id]]
if args.mode == "db":
alarms = mbdb.get_device_alarms(cnxn_string, self.mibands.keys()[dev_id])
else:
if self.mibands.keys()[dev_id] in self.devices_alarms.keys():
alarms = self.devices_alarms[self.mibands.keys()[dev_id]]
else:
alarms = []
if command == 'list':
if len(alarms) > 0:
for idx,a in enumerate(mb.alarms):
print "[%s]" % idx + str(a)
if command == 'clear':
if len(alarms) > 0:
mb.cleanAlarms()
if args.mode == "db":
mbdb.delete_all_alarms(cnxn_string, mb.addr)
else:
self.devices_alarms[self.mibands.keys()[dev_id]] = []
elif command == 'queue':
try:
hour, minute = map(lambda x: int(x), l[2].split(":"))
alarm_id = mb.queueAlarm(hour, minute)
if args.mode == "db":
mbdb.set_alarm(cnxn_string, mb.addr, mb.alarms[alarm_id], alarm_id)
else:
if len(alarms) > 0:
self.devices_alarms[self.mibands.keys()[dev_id]] += [{"enabled": True, "repetition": 128, "hour": hour, "minute": minute}]
else:
self.devices_alarms[self.mibands.keys()[dev_id]] = [{"enabled": True, "repetition": 128, "hour": hour, "minute": minute}]
except IndexError:
print "*** queue takes an hour parameter in format HH:MM"
except ValueError:
print "*** queue takes an hour parameter in format HH:MM"
elif command == 'delete':
try:
alarm_id = int(l[2])
mb.deleteAlarm(alarm_id)
if len(alarms) > 0:
if args.mode == "db":
mbdb.delete_alarm(cnxn_string, mb.addr, alarm_id)
else:
del self.devices_alarms[self.mibands.keys()[dev_id]][alarm_id]
except IndexError:
print "*** delete takes an alarm_id parameter"
except ValueError:
print "*** delete's alarm_id should be a number"
elif command == 'toggle':
try:
alarm_id = int(l[2])
mb.toggleAlarm(alarm_id)
if args.mode == "db":
mbdb.set_alarm(cnxn_string, mb.addr, mb.alarms[alarm_id], alarm_id)
else:
self.devices_alarms[self.mibands.keys()[dev_id]][alarm_id]["enabled"] = mb.alarms[alarm_id].enabled
except IndexError:
print "*** toggle takes an alarm_id parameter"
except ValueError:
print "*** toggle's alarm_id should be a number"
elif command == 'toggleday':
try:
alarm_id = int(l[2])
day_id = int(l[3])
if day_id not in range(1,8):
print "*** day_id should be between 1 (Monday) and 7 (Sunday)"
return
else:
mb.toggleAlarmDay(alarm_id, day_id-1)
if args.mode == "db":
mbdb.set_alarm(cnxn_string, mb.addr, mb.alarms[alarm_id], alarm_id)
else:
self.devices_alarms[self.mibands.keys()[dev_id]][alarm_id]["repetition"] = mb.alarms[alarm_id].repetitionMask
except IndexError:
print "*** toggleday takes an alarm_id parameter and a day_id parameter (1-7)"
except ValueError:
print "*** toggleday's alarm_id and day_id should be both numbers"
elif command == "set":
try:
alarm_id = int(l[2])
hour, minute = map(lambda x: int(x), l[3].split(":"))
mb.changeAlarmTime(alarm_id, hour, minute)
if args.mode == "db":
mbdb.set_alarm(cnxn_string, mb.addr, mb.alarms[alarm_id], alarm_id)
else:
self.devices_alarms[self.mibands.keys()[dev_id]][alarm_id]["hour"] = mb.alarms[alarm_id].hour
self.devices_alarms[self.mibands.keys()[dev_id]][alarm_id]["minute"] = mb.alarms[alarm_id].minute
except IndexError:
print "*** set takes an alarm_id parameter and an hour parameter in format HH:MM"
except ValueError:
print "*** toggleday's alarm_id and hour (HH:MM) should be both numbers"
else:
print("MiBand should be connected before viewing/changing alarms")
else:
print("MiBand should be registered before viewing/changing alarms")