}, {
'topic': constants.BEACON_CONF['event_topic'],
'payload': payload
}]
publish.multiple(msgs,
hostname=constants.MQTT_CON['host'],
port=constants.MQTT_CON['port'])
def enter_event(self):
logging.info('ENTER_EVENT mac %s', self.beacon_addr)
self.send_event('ENTER')
def leave_event(self):
logging.info('LEAVE_EVENT mac %s', self.beacon_addr)
self.send_event('LEAVE')
if __name__ == '__main__':
logging.basicConfig(level=logging.INFO,
format='%(asctime)s %(levelname)s %(message)s',
datefmt='%m-%d-%Y %H:%M:%S')
user = User()
t = threading.Thread(target=user.check)
t.start()
scanner = Scanner().withDelegate(ScanDelegate(user))
logging.info('Entering main scan loop')
while True:
scanner.scan()
def scan_devs(self, timeout=8, scan_type='active', sort='rssi'):
"""LE devices scanning
scan_type - Indicate the type of LE scan：active, passive, adv or
features.
"""
if scan_type == 'adv':
return
scanner = Scanner(self.devid).withDelegate(LEDelegate())
#print("[Debug] timeout =", timeout)
# scan() 返回的 devs 是 dictionary view。
if scan_type == 'active': # Active scan 会在 LL 发送 SCAN_REQ PDU
logger.warning(
'Before doing an active scan, make sure you spoof your BD_ADDR.'
)
logger.info('LE active scanning on %s with timeout %d sec\n' % \
(blue('hci%d'%self.devid), timeout))
devs = scanner.scan(timeout)
elif scan_type == 'passive':
logger.info('LE passive scanning on %s with timeout %d sec\n' % \
(blue('hci%d'%self.devid), timeout))
devs = scanner.scan(timeout, passive=True)
else:
logger.error('Unknown LE scan type')
return
if sort == 'rssi':
devs = list(devs) # 将 dictionary view 转换为 list
devs.sort(key=lambda d: d.rssi)
for dev in devs:
print('Addr: ', blue(dev.addr.upper()))
print('Addr type: ', blue(dev.addrType))
print('Connectable:',
green('True') if dev.connectable else red('False'))
print("RSSI: %d dB" % dev.rssi)
print("General Access Profile:")
for (adtype, desc, val) in dev.getScanData():
# 打印当前 remote LE dev 透露的所有 GAP 数据（AD structure）。
#
# 如果 bluepy.scan() 执行的是 active scan，那么这些 GAP 数据
# 可能同时包含 AdvData 与 ScanRspData。其中 AdvData 由 remote LE
# dev 主动返回，ScanRspData 由 remote BLE dev 响应 SCAN_REQ 返回。
#
# 虽然 LL 分开定义了 Advertising PDUs (ADV_IND, ADV_DIRECT_IND...)
# 和 Scanning PDUs (SCAN_REQ, SCAN_RSP)。但它们分别包含的 AdvData
# 与 ScanRspData 到了 HCI 层都被放在了 HCI_LE_Advertising_Report
# event 中。HCI_LE_Advertising_Report 的 Event_Type 标识了这些数
# 据具体来源于哪个 LL 层的 PDU。另外 ScanRspData 与 AdvData 的格式
# 完全相同，都是 GAP 协议标准定义的 AD structure。
#
# 在 LL 定义的 Advertising PDUs 中 ADV_DIRECT_IND 一定不会包含
# AdvData。其余的 ADV_IND，ADV_NONCONN_IND 以及 ADV_SCAN_IND 都
# 可能包含 AdvData。
#
# 另外 getScanData() 返回的 desc 还可以通过 ScanEntry.getDescription()
# 单独获取；val 还可以通过 ScanEntry.getValueText() 单独获取；
# adtype 表示当前一条 GAP 数据（AD structure）的类型。
print('\t' + desc + ': ', end='')
if adtype == COMPLETE_16_BIT_SERVICE_CLS_UUID_LIST:
print()
for uuid in val.split(','):
if len(uuid) == 36:
# 这里拿到的是完整的 128-bit uuid，但我们需要 16-bit uuid。
print('\t\t' + blue(uuid[4:8]))
else:
print('\t\t' + blue(uuid))
continue
elif adtype == COMPLETE_32_BIT_SERVICE_CLS_UUID_LIST:
print()
for uuid in val.split(','):
if len(uuid) == 36:
# 这里拿到的是完整的 128-bit uuid，但我们需要 32-bit uuid。
print('\t\t' + blue(uuid[0:8]))
else:
print('\t\t' + blue(uuid))
continue
elif adtype == MANUFACTURER_SPECIFIC_DATA:
val = bytes.fromhex(val)
if len(val) > 2:
print()
print(
'\t\tCompany ID:', '0x%04x' %
int.from_bytes(val[0:2], 'little', signed=False))
print('\t\tData:', val[2:])
else:
print(val)
continue
print(val)
print("\n")
def connect(self):
if self.target_address is None:
sys.stdout.write("Searching for devices....")
sys.stdout.flush()
scanner = Scanner(self.port)
scanner.withDelegate(ScanDelegate())
nearby_devices = scanner.scan(10)
if len(nearby_devices) > 0:
for dev in nearby_devices:
#look for a device name that starts with the specified target name
for (adtype, desc, value) in dev.getScanData():
#one of the data points returned by getScanData is the device's
#human-readable name. This is what we want to match against to see
#if we have discovered a Sphero device.
if value.startswith(self.target_name):
self.found_device = True
self.target_address = dev.addr
break
if self.found_device:
break
if self.target_address is not None:
sys.stdout.write("\nFound Sphero device with address: %s\n" %
(self.target_address))
sys.stdout.flush()
else:
sys.stdout.write("\nNo Sphero devices found.\n")
sys.stdout.flush()
sys.exit(1)
else:
sys.stdout.write("Connecting to device: " + self.target_address +
"...")
try:
#Connect to sphero and populate services and characteristics
self.peripheral = btle.Peripheral(self.target_address,
addrType=btle.ADDR_TYPE_RANDOM)
sys.stdout.write("Connected!\nFinding services...")
sys.stdout.flush()
self.peripheral.getServices()
self.ble_service = self.peripheral.getServiceByUUID(
btle.UUID(self.UUIDs['BLE_SVC']))
self.anti_dos_characteristic = self.ble_service.getCharacteristics(
self.UUIDs['ANTI_DOS_CHAR'])[0]
self.robot_control_service = self.peripheral.getServiceByUUID(
self.UUIDs['BOT_CTRL_SVC'])
self.wake_characteristic = self.ble_service.getCharacteristics(
self.UUIDs['WAKE_CHAR'])[0]
self.tx_power_characteristic = self.ble_service.getCharacteristics(
self.UUIDs['TX_PWR_CHAR'])[0]
self.anti_dos_characteristic = self.ble_service.getCharacteristics(
self.UUIDs['ANTI_DOS_CHAR'])[0]
self.commands_characteristic = self.robot_control_service.getCharacteristics(
self.UUIDs['CMD_CHAR'])[0]
self.response_characteristic = self.robot_control_service.getCharacteristics(
self.UUIDs['RESP_CHAR'])[0]
sys.stdout.write("Services found!\nEnabling dev mode...")
sys.stdout.flush()
self._enable_dev_mode()
except btle.BTLEException as error:
sys.stdout.write(error.strerror)
sys.stdout.flush()
time.sleep(5.0)
sys.exit(1)
sys.stdout.write("Done.\n")
sys.stdout.flush()
return True
tempOZ = ((ord(data[5]) << 8) + ord(data[4])) / 100
if tempOZ > 327.67:
tempOZ = -(655.35 - tempOZ)
if len(yO) < 600:
yO.appendleft(tempOZ)
else:
yO.pop()
yO.appendleft(tempOZ)
bt_addresses = ['00:0b:57:51:bd:7e', '00:0b:57:51:c0:a9']
connections = []
connection_threads = []
scanner = Scanner(0)
class ListenerThread(threading.Thread):
def __init__(self, connection_index):
threading.Thread.__init__(self)
self.connection_index = connection_index
def run(self):
connection = connections[self.connection_index]
connection.setDelegate(MyDelegate(self.connection_index))
connection.writeCharacteristic(79, "\x01\x00")
connection.writeCharacteristic(82, "\x01\x00")
while True:
if connection.waitForNotifications(1):
if(prox == 2):
break
return prox
## Initiate the Local class
Display = Display()
Local = Local()
Local.localClient.subscribe(Local.topicWeight)
## Initialize the Azure class
Azure = Azure()
## Initiate Receiver class
Receiver = Receiver()
scanner = Scanner()
publishData = '{"id":"00815414", "DeviceID":"Receiver_WeighBridge", "EventType":"ENTRY_AUTH", "iIndustry":"true", "Devices":{ "TruckID":"111", "BLEID":"1111", "dynamic1":"11", "dynamic2":"11111" }, "Data":{}}'
while True:
result = None
try:
if(ScanInit):
rssi, address = Receiver.rangeScanner()
if(rssi > -45):
result = Receiver.proximityScanner(address)
if(result >= 2):
Azure.azureClient.publish("devices/" + Azure.device_id + "/messages/events/",
publishData, qos=1)
ScanInit = False
except (KeyboardInterrupt, SystemExit):
print()
def connect(pi):
from bluepy.btle import Scanner, DefaultDelegate, Peripheral, ADDR_TYPE_RANDOM, UUID, BTLEException
device = None
addr = None
_LOGGER.debug("Starting plejd connection")
disconnect(pi)
scanner = Scanner()
for i in range(1, 10):
devs = sorted(list(scanner.scan(1)), key=lambda d: d.rssi)[::-1]
for d in devs:
for (adtype, desc, value) in d.getScanData():
if (adtype == 8 and value == "P mesh"):
try:
dev = Peripheral(d, addrType=ADDR_TYPE_RANDOM)
if dev.getServiceByUUID(UUID(PLEJD_SERVICE)):
device = dev
else:
dev.disconnect()
break
except BTLEException as e:
_LOGGER.warning(
"failed connecting to device '%s' : '%s'" %
(d.addr, e))
if device:
break
if device is None:
_LOGGER.warning("no device found on iteration %d" % (i))
else:
break
if device == None:
_LOGGER.warning("Failed to find a Plejd device to connect to")
return
_LOGGER.debug("Connected to Plejd device '%s'" % (device.addr))
pi["device"] = device
pi["address"] = binascii.a2b_hex(device.addr.replace(':', ''))[::-1]
pi["handles"] = {}
pi["handles"]["last_data"] = pi["device"].getCharacteristics(
uuid=UUID(LAST_DATA_UUID))[0].getHandle()
pi["handles"]["auth"] = pi["device"].getCharacteristics(
uuid=UUID(AUTH_UUID))[0].getHandle()
pi["handles"]["ping"] = pi["device"].getCharacteristics(
uuid=UUID(PING_UUID))[0].getHandle()
pi["handles"]["data"] = pi["device"].getCharacteristics(
uuid=UUID(DATA_UUID))[0].getHandle()
class PlejdDelegate(DefaultDelegate):
def handleNotification(self, handle, value):
if handle == pi["handles"]["last_data"]:
dec = plejd_enc_dec(pi["key"], pi["address"], value)
# check if this is a device we care about
if dec[0] in PLEJD_DEVICES:
device = PLEJD_DEVICES[dec[0]]
else:
_LOGGER.debug("no match for device '%02x' (%s)" %
(dec[0], binascii.b2a_hex(dec)))
return
dim = 0xffff
state = None
if dec[3:5] == b'\x00\xc8' or dec[3:5] == b'\x00\x98':
# 00c8 and 0098 both mean state+dim
state = dec[5]
dim = int.from_bytes(dec[6:8], 'little')
elif dec[3:5] == b'\x00\x97':
# 0097 is state only
state = dec[5]
else:
_LOGGER.debug(
"no match for command '%s' (%s)" %
(binascii.b2a_hex(dec[3:5]), binascii.b2a_hex(dec)))
return
if (state == 0):
state = False
else:
state = True
device.update_state(state, dim)
class PlejdNotificationThread(Thread):
def __init__(self):
Thread.__init__(self)
self.stopped = True
_LOGGER.debug("setting up notification thread")
def stop(self):
_LOGGER.debug("stopping notification thread")
self.stopped = True
import time
def run(self):
from bluepy.btle import BTLEInternalError
_LOGGER.debug("starting notification thread")
self.stopped = False
while True:
try:
pi["device"].waitForNotifications(1)
except BTLEInternalError as e:
_LOGGER.warning("Encountered bluepy internal error: '%s'" %
(e))
if self.stopped:
break
_LOGGER.debug("exiting notification thread")
authenticate(pi)
# the notification handle is last_data + 2
pi["device"].writeCharacteristic(pi["handles"]["last_data"] + 2,
b'\x02\x00')
pi["device"].withDelegate(PlejdDelegate())
pi["thread"] = PlejdNotificationThread()
pi["thread"].start()
_LOGGER.debug("all plejd setup completed")
def get_current_position():
MIN = 30
MAX = 100
SCALE = 1.3
scanner = Scanner().withDelegate(ScanDelegate())
devices = scanner.scan(1.9)
devlist = ['30:ae:a4:9c:e7:c2', '30:ae:a4:97:6c:26', '30:ae:a4:9c:8f:a2']
global ds_test
for dev in devices:
if dev.addr in devlist:
# print("ADDR: %s" % (dev.addr))
data = [[
time.time(), dev.addr, -1 * dev.rssi, dev.iface, dev.addrType,
dev.getValueText(1),
dev.getValueText(10),
dev.getValueText(255)
]]
#data = [[time.time()]]
ds_test = ds_test.append(data)
#print("bucle: %d" % len(ds_test))
if len(ds_test) == 0:
return None
# else:
# print("bucle: %d" % (len(ds_test[ds_test[2]>=MIN])))
# print("bucle2: %d" % len(ds_test))
# return None
ds_test = ds_test[ds_test[2] >= MIN]
if debug:
print("bucle2: %d" % len(ds_test))
print(len(ds_test[ds_test[0] - (time.time()) < 2000]))
#ds_test["rssi_norm"]=MAX-ds_test[2]
ds_test["rssi_norm"] = (ds_test[2] - MIN) / (MAX - MIN)
#ds_test["rssi_norm"]=1-ds_test["rssi_norm"]
ds_test["rssi_norm"] = ds_test["rssi_norm"] * SCALE
ds_test_b3 = ds_test[ds_test[1] == "30:ae:a4:97:6c:26"] # 3
ds_test_b1 = ds_test[ds_test[1] == "30:ae:a4:9c:e7:c2"] # 1
ds_test_b2 = ds_test[ds_test[1] == "30:ae:a4:9c:8f:a2"] # 2
ds_b1 = 0
ds_b2 = 0
ds_b3 = 0
if len(ds_test_b1) > 0 and time.time() - ds_test_b1.iloc[-1][0] < 10:
ds_b1 = ds_test_b1.iloc[-1]["rssi_norm"]
if len(ds_test_b2) > 0 and time.time() - ds_test_b2.iloc[-1][0] < 10:
ds_b2 = ds_test_b2.iloc[-1]["rssi_norm"]
if len(ds_test_b3) > 0 and time.time() - ds_test_b3.iloc[-1][0] < 10:
ds_b3 = ds_test_b3.iloc[-1]["rssi_norm"]
print("Beacon 1: %s" % (ds_b1))
print("Beacon 2: %s" % (ds_b2))
print("Beacon 3: %s" % (ds_b3))
if debug:
print("Summary:")
print("#########")
print("len ds_test %d" % (len(ds_test)))
print(ds_b1)
print(ds_b2)
print(ds_b3)
print("#########")
print("Position 1: %s" % (ds_b1))
print("Position 2: %s" % (ds_b2))
print("Position 3: %s" % (ds_b3))
point = returnpoint(0, 0, ds_b1, 0, 1, ds_b2, 1, 0.5, ds_b3)
if point == None:
point = Point(0, 0)
data = [[
time.time() * 1000,
str(point.x),
str(point.y), 0, 0, ds_b1, 0, 1, ds_b2, 1, 0.5, ds_b3
]]
temp = pd.DataFrame(data)
temp.to_csv('/home/pepo/Documents/nissan_code/Loc_csv.csv',
mode='a',
header=False)
return point
def scan(self, timeout=10.0):
delegate = _ScanDelegate(self._callback)
scanner = Scanner(self._interface).withDelegate(delegate)
devices = list(filter(_DEVICE_FILTER, scanner.scan(float(timeout))))
return devices
def hex2int(_HEX):
_BIN = bytes.fromhex(_HEX)
_Rev = _BIN[::-1]
_HEX = _Rev.hex()
return int(_HEX, 16)
# Fill list with used sensors
registereddevices = ['4008DF']
knownddevices = []
while True:
scan = Scanner(0)
devs = scan.scan(10.0)
for device in devs:
if device.addr in knownddevices:
for (Code, desc, value) in device.getScanData():
# Check if string is indeed 36 characters long
count = len(value)
if count == 36:
# Check if mac adress is in string
mac = (device.addr.replace(':', ''))
m = re.search('/*{0}'.format(mac), value)
if m:
def scan(timeout=None, mac_address=None):
scanner = Scanner()
return get_switchmates(scanner.scan(timeout), mac_address)
def scanDevices():
class ScanDelegate(DefaultDelegate):
def __init__(self):
DefaultDelegate.__init__(self)
scanner = Scanner().withDelegate(ScanDelegate())
devices = scanner.scan(10.0)
for dev in devices:
# getScanData récupère les données adtype, desc et value (qui sont des tuples)
#creation de la variable dictionnaire pour les adtype et pour les temperatures
adtype8 = ""
adtype22 = ""
dicoTemperature = {}
for (adtype, value) in dev.getScanData():
if adtype == 8:
adtype8 = value
if adtype == 22:
adtype22 = value
if len(adtype22) == 38 and adtype22[4:10] == "113901" and adtype22[32:39] == "000000" :
if 11000000 < int(adtype22[12:20]) < 12000000:
# save l'index correspondant au numéro d'identification dans var valeurId
valeurId = adtype22[12:20]
# save l'index correspondant à la valeur batterie dans var valeurBatterieHexa
valeurBatterieHexa = adtype22[20:22]
# save l'index correspondant à la valeur température dans var valeurtempHexa
valeurTempHexa = adtype22[24:28]
# convert hexa to decimal (nomVar_D, base16)
# On convertit l'hexa de la batterie en decimale
valeurBatterie = int(valeurBatterieHexa, 16)
# On convertit l'hexa de la temperature en decimale
valeurTemp = int(valeurTempHexa, 16)
#On deplace la décimale vers la gauche de 2
temperature = valeurTemp * (1/100)
# print pour voir ce qui est renvoyé
print(time.strftime('%d/%m/%Y - %H:%M:%S'))
print(adtype8)
print(valeurId)
print("{0:.2f}".format(temperature))
print(valeurBatterie)
# vérifie la température avec le seuil :
# si c'est en dehors du seuil
if valeurTemp < 2400 or valeurTemp > 3000 :
# vérifie le capteur est deja dans le dictionnaire dicoTemperature
if adtype8 not in dicoTemperature :
# si le capteur n'est pas dedans, il ajoute le capteur et sa temp dedans puis envoi le mail messageKO de danger
dicoTemperature.update({adtype8: valeurTemp})
envoiMail(adtype8, valeurId, temperature, valeurBatterie, bool(True))
# Message qui s'affiche si le mail a été envoyé avec succés
print ("Enregistrement des températures pour les capteurs. Mail envoyé avec succés a %s" % (msg['To']))
# si c'est compris dans le seuil
else :
# vérifie si capteur existant dans dicoTemperature
if adtype8 in dicoTemperature :
# si capteur est déjà existant, supprime ses données du dico et envoie un mail messageOK de rétablissement
del dicoTemperature[adtype8]
envoiMail(adtype8, valeurId, temperature, valeurBatterie, bool(False))
else :
print("probleme if 11000000 >< 12000000")
else :
print("probleme if len(adtype22)")
def main():
# uuid definition
targetDevice = ""
targetUUID = UUID("08590f7e-db05-467e-8757-72f6f66666d4")
# targetUUID = UUID(0x2a2b)
serviceUUID = UUID("e20a39f4-73f5-4bc4-a12f-17d1ad666661")
# scanning for Bluetooth LE device
# P.S. root permission is needed
print "scanning started..."
scanner = Scanner().withDelegate(ScanDelegate())
devices = scanner.scan(5)
print "\n\nscanning completed...\n found %d device(s)\n" % len(devices)
for dev in devices:
print "Device %s (%s), RSSI=%d dB" % (dev.addr, dev.addrType, dev.rssi)
for (adtype, desc, value) in dev.getScanData():
print " %s = %s" % (desc, value)
try:
p = Peripheral(dev.addr, "random")
ch = p.getCharacteristics(uuid=targetUUID)
if len(ch) > 0:
print "the desired target found. the address is", dev.addr
targetDevice = dev.addr
except:
# print "Unexpected error:", sys.exc_info()[0]
print "Unable to connect"
print " "
finally:
p.disconnect()
# scanning completed, now continue to connect to device
if targetDevice == "":
# the target is not found. end.
print "no target was found."
else:
# the target found, continue to subscribe.
print "\n\nthe target device is ", targetDevice
print "now try to subscribe..."
try:
# try to get the handle first
p = Peripheral(targetDevice, "random")
p.setDelegate(NotificationDelegate())
# svc = p.getServiceByUUID(serviceUUID)
ch = p.getCharacteristics(
uuid=targetUUID)[0] # svc.getCharacteristics(targetUUID)[0]
handle = ch.getHandle()
print handle
ch.write(struct.pack('<bb', 0x01, 0x00))
# ch.write(bytes('aa', 'utf-8'))
# p.writeCharacteristic(handle, struct.pack('<bb', 0x01, 0x00), True)
print
# Main loop
while True:
if p.waitForNotifications(5):
# handleNotification() was called
continue
print "Waiting..."
# Perhaps do something else here
# except:
# print "Unexpected error:", sys.exc_info()[0]
finally:
p.disconnect()
def __init__(self):
self.logger = logging.getLogger()
self.scanner = Scanner(iface=0)
def __init__(self):
self._scanner = Scanner()
self._peripheral = Peripheral()
self._desk = None
self.config = Config()
from bluepy.btle import Scanner, DefaultDelegate
from miband2 import MiBand2, ActivityDelegate
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 scanForDevices():
scanner = Scanner().withDelegate(DefaultDelegate()) #ScanDelegate())
devices = scanner.scan(4.0)
return devices
# Scan Response
if isNewData:
print "Received more data", dev.addr, dev.getScanData()
def handleNotification(self, cHandle, data):
# Only print the value when the handle is 40 (the battery characteristic)
if cHandle == 40:
buttonPressed = struct.unpack('B', data)[0]
print buttonPressed
button_publish(buttonPressed, hexi_addr)
handler = BTEventHandler()
# Create a scanner with the handler as delegate
scanner = Scanner().withDelegate(handler)
# Start scanning. While scanning, handleDiscovery will be called whenever a new device or new data is found
devs = scanner.scan(10.0)
# Get HEXIWEAR's address
hexi_addr = [dev for dev in devs
if dev.getValueText(0x8) == 'HEXIWEAR'][0].addr
# hexi_addr = '00:2A:40:08:00:10'
# Create a Peripheral object with the delegate
hexi = Peripheral().withDelegate(handler)
# Connect to Hexiwear
hexi.connect(hexi_addr)
def sc():
scne = Scanner()
devices = scne.scan(0.5)
return devices
def __init__(self):
self.scanner = Scanner().withDelegate(ScanDelegate())
def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
"""Setup SPIN remote(s)."""
from bluepy.btle import BTLEException, DefaultDelegate, Peripheral, Scanner
bl_dev = config.get(ATTR_DEVICE, DEFAULT_DEVICE)
scan_interval = config.get(ATTR_SCAN_INTERVAL, DEFAULT_SCAN_INTERVAL)
scan_timeout = config.get(ATTR_SCAN_TIMEOUT, DEFAULT_SCAN_TIMEOUT)
checking_devices = False
connected_to_device = False
homeassistant_stopped = False
known_device_adresses = []
spins = {}
entities = {}
# Would be a nice moment to check if bl_dev is even valid.
class NotificationDelegate(DefaultDelegate):
"""
If a notification is received, it will be handled by the handleNotification def in here
"""
def __init__(self, hass, spin):
DefaultDelegate.__init__(self)
self.hass = hass
self.spin = spin
def handleNotification(self, cHandle, data):
global ACTION_TO_STRING
if cHandle == 0x30: # Action
self.spin['entity'].action_notification(
ACTION_TO_STRING[ord(data)])
elif cHandle == 0x3c: # Profile change
self.spin['entity'].profile_update(data[0])
@asyncio.coroutine
def start_receiving_notifications(hass, device, peripheral):
"""Loop to receive notifications"""
nonlocal checking_devices
nonlocal connected_to_device
nonlocal homeassistant_stopped
nonlocal spins
while not homeassistant_stopped:
try:
hasNotification = yield from hass.loop.run_in_executor(
None, peripheral.waitForNotifications, 1.0)
except (BTLEException, AttributeError) as error:
_LOGGER.warning(error)
checking_devices = False
connected_to_device = False
if not connected_to_device:
spins[device.addr]['entity'].is_connected(False)
break
@asyncio.coroutine
def async_handle_spin(device, peripheral=None):
"""Prepare SPIN remote to be used by HASS"""
nonlocal connected_to_device
nonlocal spins
global COMMAND_CHARACTERISTIC_UUID
global ACTION_CHARACTERISTIC_UUID
global PROFILE_ID_CHARACTERISTIC_UUID
global UUID_CLIENT_CHARACTERISTIC_CONFIG
if not peripheral:
try:
peripheral = yield from hass.loop.run_in_executor(
None, Peripheral, device)
spins[device.addr]['device'] = device
spins[device.addr]['peripheral'] = peripheral
spins[device.addr]['entity'].is_connected(True)
except BTLEException as error:
_LOGGER.warning(error)
if peripheral:
connected_to_device = True
services = yield from hass.loop.run_in_executor(
None, peripheral.getServices)
for service in services:
if service.uuid == SPIN_SERVICE_UUID:
actionCharacteristic = service.getCharacteristics(
ACTION_CHARACTERISTIC_UUID)
profile_idCharacteristic = service.getCharacteristics(
PROFILE_ID_CHARACTERISTIC_UUID)
commandCharacteristic = service.getCharacteristics(
COMMAND_CHARACTERISTIC_UUID)
_LOGGER.info("Turning notifications on")
if actionCharacteristic:
descriptors = actionCharacteristic[0].getDescriptors(
UUID_CLIENT_CHARACTERISTIC_CONFIG)
descriptors[0].write(struct.pack('<bb', 0x01, 0x00),
True)
if profile_idCharacteristic:
profile_id = profile_idCharacteristic[0].read()
descriptors = profile_idCharacteristic[
0].getDescriptors(
UUID_CLIENT_CHARACTERISTIC_CONFIG)
descriptors[0].write(struct.pack('<bb', 0x01, 0x00),
True)
spins[device.addr]['entity'].profile_update(
profile_id[0])
if commandCharacteristic:
commandCharacteristic[0].write(
struct.pack('<bb', 0x08, 0x01), True)
peripheral.withDelegate(
NotificationDelegate(hass, spins[device.addr]))
hass.async_add_job(start_receiving_notifications, hass,
device, peripheral)
@asyncio.coroutine
def async_new_device_found(device):
"""Check if the newly found BLE device is a SPIN"""
nonlocal checking_devices
nonlocal connected_to_device
nonlocal known_device_adresses
nonlocal spins
nonlocal entities
global DISCOVERY_UUID
global SPIN_SERVICE_UUID
global COMMAND_CHARACTERISTIC_UUID
_LOGGER.info("Checking " + device.addr)
checking_devices = True
try:
peripheral = yield from hass.loop.run_in_executor(
None, Peripheral, device)
services = yield from hass.loop.run_in_executor(
None, peripheral.getServices)
if not device.addr in spins:
# Walk through the list of services to see if one of them matches the DISCOVERY_UUID
for service in services:
if service.uuid == DISCOVERY_UUID:
sdc1 = SDC1('spin_' + str(len(spins) + 1), 'connected',
device.addr)
spins[device.addr] = {
'device': device,
'peripheral': peripheral,
'entity': sdc1
}
entities[DOMAIN + '.' + sdc1.name] = sdc1
connected_to_device = True
yield from async_add_devices([sdc1])
_LOGGER.info("Connected to BLE device " + device.addr)
known_device_adresses.append(device.addr)
if connected_to_device == False:
peripheral.disconnect()
else:
yield from async_handle_spin(device, peripheral)
except BTLEException as error:
_LOGGER.warning(error)
checking_devices = False
connected_to_device = False
@asyncio.coroutine
def async_on_time_interval(now: dt_util.dt.datetime):
"""Start scanning for BLE devices"""
nonlocal scan_timeout
nonlocal known_device_adresses
nonlocal checking_devices
nonlocal connected_to_device
devices = []
if not checking_devices and not connected_to_device:
checking_devices = True
_LOGGER.info("Scanning for BLE devices for " + str(scan_timeout) +
" seconds")
try:
devices = yield from hass.loop.run_in_executor(
None, scanner.scan, scan_timeout)
except BTLEException as error:
_LOGGER.warning(error)
_LOGGER.info("Found " + str(len(devices)) + " BLE devices")
for device in devices:
if not device.addr in known_device_adresses:
yield from async_new_device_found(device)
elif device.addr in spins:
_LOGGER.info("SPIN found, reconnecting...")
yield from async_handle_spin(device)
checking_devices = False
scanner = Scanner(bl_dev)
# Because we sometimes get into trouble if we start searching to early; we'll start once Home Assistant is ready
@asyncio.coroutine
def async_on_homeassistant_start(event):
"""Once Home Assistant is started, we'll scan every 30 seconds or so"""
nonlocal scan_interval
interval = timedelta(seconds=scan_interval)
remove_on_time_interval = async_track_time_interval(
hass, async_on_time_interval, interval)
hass.async_add_job(async_on_time_interval, None)
@asyncio.coroutine
def async_on_homeassistant_stop(event):
"""Once Home Assistant stops, prevent further futures from being created"""
nonlocal homeassistant_stopped
homeassistant_stopped = True
# Add listeners:
hass.bus.async_listen_once(EVENT_HOMEASSISTANT_START,
async_on_homeassistant_start)
hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP,
async_on_homeassistant_stop)
@asyncio.coroutine
def async_handle_profile_service(call):
"""Handle profile service calls"""
nonlocal spins
profileRegex = r"profile_(\d+)"
profile = call.data.get(ATTR_PROFILE,
DEFAULT_PROFILE) # Default to current profile?
match = re.search(profileRegex, profile)
entity_ids = call.data.get('entity_id')
if match:
peripheral = spins[entities[entity_ids[0]].address]['peripheral']
services = yield from hass.loop.run_in_executor(
None, peripheral.getServices)
for service in services:
if service.uuid == SPIN_SERVICE_UUID:
profile_idCharacteristic = service.getCharacteristics(
PROFILE_ID_CHARACTERISTIC_UUID)
if profile_idCharacteristic:
profile_idCharacteristic[0].write(
struct.pack('<b', int(match.group(1))), True)
spins[entities[
entity_ids[0]].address]['entity'].profile_update(
int(match.group(1)))
@asyncio.coroutine
def async_handle_color_service(call):
"""Handle LED color service calls"""
nonlocal spins
nonlocal entities
red, green, blue = call.data.get('rgb_color', [0, 0, 0])
entity_ids = call.data.get('entity_id')
peripheral = spins[entities[entity_ids[0]].address]['peripheral']
services = yield from hass.loop.run_in_executor(
None, peripheral.getServices)
for service in services:
if service.uuid == SPIN_SERVICE_UUID:
commandCharacteristic = service.getCharacteristics(
COMMAND_CHARACTERISTIC_UUID)
if commandCharacteristic:
if red + green + blue < 1:
commandCharacteristic[0].write(struct.pack(
'<b', 0x07), True) # Remove forced LED color
else:
commandCharacteristic[0].write(
struct.pack('<bBBB', 0x09, red, green, blue), True)
hass.services.async_register(DOMAIN, 'profile',
async_handle_profile_service)
hass.services.async_register(DOMAIN, 'rgb_color',
async_handle_color_service)
return True
def init_scanner():
scanner = Scanner()
scanner.clear()
scanner.start()
return scanner
def scan_and_connect(is_first=True):
global SCAN_TIME
global TARGET_MANUFA_UUID
global TARGET_DEVICE_NAME
global gTargetDevice
global gSocketClient
#
# scanning for a while
#
scanner = Scanner().withDelegate(ScanDelegate())
print("+--- BLE device scan %sstarted..." % ('re' if not is_first else ''))
devices = scanner.scan(SCAN_TIME)
print("\n+--- BLE device scan completed... [%d] devices are scanned" %
gScannedCount)
#
# check to match BOSCH SCD device identifiers
#
for dev in devices:
matching_count = 0
for (adtype, desc, value) in dev.getScanData():
if adtype == 255 and TARGET_MANUFA_UUID in value:
matching_count += 1
print("\tfound target (AD Type=%d) '%s' is '%s'" %
(adtype, desc, value))
if adtype == 9 and TARGET_DEVICE_NAME in value:
matching_count += 1
print("\tfound target (AD Type=%d) '%s' is '%s'" %
(adtype, desc, value))
if matching_count >= 2:
print("\tfound BOSCH SCD device!")
print("+--- device address [%s], type=[%s], RSSI=[%d]dB" %
(dev.addr, dev.addrType, dev.rssi))
gTargetDevice = dev
break
if gTargetDevice != None:
break
#
# if none found then exiting
#
if gTargetDevice == None:
print("\tno matching device found... Exiting...")
gSocketClient.close()
sys.exit(1)
#
# connect
#
print("+--- connecting [%s], type=[%s]" %
(gTargetDevice.addr, gTargetDevice.addrType))
p = None
retry = 0
while p == None:
try:
p = Peripheral(gTargetDevice.addr, gTargetDevice.addrType)
except:
print(
"\tBLE device connection error occured... retry after 3 sec..."
)
retry += 1
if retry > 3:
print("\tBLE device connection error occured... exiting...")
gSocketClient.close()
sys.exit(-1)
time.sleep(3)
#
# should increase MTU
#
p.setMTU(SCD_MAX_MTU)
return p
def ScanNetwork():
global rank, iterval_for_scan, interval_for_sending, macAddr
subprocess.call("sudo hciconfig hci0 piscan",shell=True);
interval = random.uniform(iterval_for_scan,iterval_for_scan_random)
with open("clog.txt","a") as input_file:
input_file.write(str(datetime.datetime.now())+ "|"+"start scan" + '\n')
input_file.close()
scanner = Scanner()#.withDelegate(ScanDelegate())
devices = scanner.scan(interval) # 0 = loop
with open("clog.txt","a") as input_file:
input_file.write(str(datetime.datetime.now())+ "|"+"end scan" + '\n')
input_file.close()
###############################################################
## rerank first
if (rank != 0 ): # if not the server, rerank
print "reranking..."
rank = -1
for dev in devices:
dict = {}
for (adtype, desc, value) in dev.getScanData():
dict[adtype] = value
# handle the flag == 88
if (dict.has_key(1) and dict[1] == '88'):
###############################################################
# handle type = 0xc1
if (dict.has_key(0xc1)):
data = dict[0xc1]
print "recv data [0xC1]: ", data
# parse cmd
cmd = data[0:2]
data = data[2:]
print "cmd: ", cmd, ":",data
###############################################################
if (cmd == '03'):
print "Device %s (%s), RSSI=%d dB" % (dev.addr, dev.addrType, dev.rssi)
for (adtype, desc, value) in dev.getScanData():
print " %s = %s" % (desc, value)
for key in dict:
print " msg %d = %s" % (key, dict[key])
handle_cmd_03(data)
###############################################################
## other task:
for dev in devices:
dict = {}
for (adtype, desc, value) in dev.getScanData():
dict[adtype] = value
# handle the flag == 88
if (dict.has_key(1) and dict[1] == '88'):
###############################################################
# handle type = 0xc1
if (dict.has_key(0xc1)):
data = dict[0xc1]
print "recv data [0xC1]: ", data
# parse cmd
cmd = data[0:2]
data = data[2:]
print "cmd: ", cmd, ":",data
###############################################################
# cmd 01: upload to server
if (cmd == '01'):
print "Device %s (%s), RSSI=%d dB" % (dev.addr, dev.addrType, dev.rssi)
for (adtype, desc, value) in dev.getScanData():
print " %s = %s" % (desc, value)
for key in dict:
print " msg %d = %s" % (key, dict[key])
handle_cmd_01(data)
# cmd 02: download to client
if (cmd == '02'):
print "Device %s (%s), RSSI=%d dB" % (dev.addr, dev.addrType, dev.rssi)
for (adtype, desc, value) in dev.getScanData():
print " %s = %s" % (desc, value)
for key in dict:
print " msg %d = %s" % (key, dict[key])
handle_cmd_02(data)
def scanLE(n, devices1):
scanner = Scanner(n)
devices = scanner.scan(1)
for dev in devices:
devices1.append(str(dev.addr + "," + str(dev.rssi) + "," + str(n)))
def handle_request(self, method, params):
"""Handle requests from Scratch"""
if self.delegate:
# Do not allow notification during request handling to avoid
# websocket server errors
self.delegate.restart_notification_event.clear()
logger.debug("handle request to BLE device")
logger.debug(method)
if len(params) > 0:
logger.debug(params)
res = {"jsonrpc": "2.0"}
err_msg = None
if self.status == self.INITIAL and method == 'discover':
if not bluepy_helper_cap.is_set():
logger.error("Capability is not set to bluepy helper.")
logger.error("Run bluepy_helper_cap(.py).")
logger.error("e.g. $ bluepy_helper_cap")
logger.error("e.g. $ sudo bluepy_helper_cap.py")
sys.exit(1)
found_ifaces = 0
for i in range(self.MAX_SCANNER_IF):
scanner = Scanner(iface=i)
try:
devices = scanner.scan(10.0)
for dev in devices:
if self.matches(dev, params['filters']):
self.found_devices.append(dev)
found_ifaces += 1
logger.debug(f"BLE device found with iface #{i}")
except BTLEManagementError as e:
logger.debug(f"BLE iface #{i}: {e}")
if found_ifaces == 0:
err_msg = "Can not scan BLE devices. Check BLE controller."
logger.error(err_msg)
res["error"] = {"message": err_msg}
self.status = self.DONE
if len(self.found_devices) == 0 and not err_msg:
err_msg = (f"No BLE device found: {params['filters']}. "
"Check BLE device.")
res["error"] = {"message": err_msg}
logger.error(err_msg)
self.status = self.DONE
else:
res["result"] = None
self.status = self.DISCOVERY
self.ble_thread = self.BLEThread(self)
self.ble_thread.start()
elif self.status == self.DISCOVERY and method == 'connect':
logger.debug("connecting to the BLE device")
self.device = self.found_devices[params['peripheralId']]
self.deviceName = self.device.getValueText(
0x9) or self.device.getValueText(0x8)
try:
self.perip = Peripheral(self.device)
logger.info(
f"connected to the BLE peripheral: {self.deviceName}")
except BTLEDisconnectError as e:
logger.error(
f"failed to connect to the BLE device \"{self.deviceName}\": {e}"
)
self.status = self.DONE
if self.perip:
res["result"] = None
self.status = self.CONNECTED
self.delegate = self.BLEDelegate(self)
self.perip.withDelegate(self.delegate)
self._cache_characteristics()
else:
err_msg = f"BLE connect failed: {self.deviceName}"
res["error"] = {"message": err_msg}
self.status = self.DONE
elif self.status == self.CONNECTED and method == 'read':
logger.debug("handle read request")
service_id = params['serviceId']
chara_id = params['characteristicId']
c = self._get_characteristic(chara_id)
if not c or c.uuid != UUID(chara_id):
logger.error(f"Failed to get characteristic {chara_id}")
self.status = self.DONE
else:
with self.lock:
b = c.read()
message = base64.standard_b64encode(b).decode('ascii')
res['result'] = {'message': message, 'encode': 'base64'}
if params.get('startNotifications') == True:
self.startNotifications(service_id, chara_id)
elif self.status == self.CONNECTED and method == 'startNotifications':
logger.debug("handle startNotifications request")
service_id = params['serviceId']
chara_id = params['characteristicId']
self.startNotifications(service_id, chara_id)
elif self.status == self.CONNECTED and method == 'stopNotifications':
logger.debug("handle stopNotifications request")
service_id = params['serviceId']
chara_id = params['characteristicId']
self.stopNotifications(service_id, chara_id)
elif self.status == self.CONNECTED and method == 'write':
logger.debug("handle write request")
service_id = params['serviceId']
chara_id = params['characteristicId']
c = self._get_characteristic_cached(chara_id)
if not c or c.uuid != UUID(chara_id):
logger.error(f"Failed to get characteristic {chara_id}")
self.status = self.DONE
else:
if params['encoding'] != 'base64':
logger.error(
"encoding other than base 64 is not "
"yet supported: ", params['encoding'])
msg_bstr = params['message'].encode('ascii')
data = base64.standard_b64decode(msg_bstr)
logger.debug("getting lock for c.write()")
with self.lock:
c.write(data)
logger.debug("released lock for c.write()")
res['result'] = len(data)
logger.debug(res)
return res
from bluepy.btle import Scanner
""" Scans for available devices. """
scan = Scanner()
sec = 5
print("Scanning for %s seconds" % sec)
devs = scan.scan(sec)
print("Scooters found:")
for dev in devs:
localname = dev.getValueText(9)
if localname and localname.startswith("MIScooter"):
print(" %s, addr=%s, rssi=%d" % (localname, dev.addr, dev.rssi))
def scanForNistSensors():
scanner = Scanner().withDelegate(ScanDelegate())
scanner.scan(.1)
if foundNistSensor == 0:
print "Didn't find any nist sensors..."
return False
p = Peripheral(esp32Address)
p.setMTU(500)
#svcList = p.getServices()
#print "Handle UUID Properties"
#print "-------------------------------------------------------"
#for svc in svcList:
# print (str(svc.uuid))
#chList = p.getCharacteristics()
#print "Handle UUID Properties"
#print "-------------------------------------------------------"
#for ch in chList:
# print (" 0x"+ format(ch.getHandle(),'02X') +" "+str(ch.uuid) +" " + ch.propertiesToString())
nist_service_uuid = UUID("0000ffe0-0000-1000-8000-00805f9b34fb")
nist_characteristic_uuid = UUID("beb5483e-36e1-4688-b7f5-ea07361b26a8")
nistService = p.getServiceByUUID(nist_service_uuid)
#nistCharacteristic = p.getCharacteristics(nist_characteristic_uuid)[0]
nistCharacteristic = nistService.getCharacteristics("beb5483e-36e1-4688-b7f5-ea07361b26a8")[0]
#readBytes = bytes(p.readCharacteristic(0x2A))
#readBytes = bytes(nistCharacteristic.read())
#print binascii.hexlify(readBytes)
#with open('/home/pi/Desktop/esp32-ndn-ble/src/readBytes.txt', 'a') as the_file:
# the_file.seek(0)
# the_file.truncate()
# the_file.write(binascii.hexlify(readBytes))
#TlvData = Blob(readBytes)
#data = Data()
#data.wireDecode(TlvData)
# Use a hard-wired secret for testing. In a real application the signer
# ensures that the verifier knows the shared key and its keyName.
key = Blob(bytearray([
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
]))
#if KeyChain.verifyDataWithHmacWithSha256(data, key):
# dump("Hard-coded data signature verification: VERIFIED")
#else:
# dump("Hard-coded data signature verification: FAILED")
freshData = Data(Name("/netInfo"))
signature = HmacWithSha256Signature()
signature.getKeyLocator().setType(KeyLocatorType.KEYNAME)
signature.getKeyLocator().setKeyName(Name("key1"))
freshData.setSignature(signature)
freshData.setContent("EdwardPi\n11111111\n192.168.4.1\n")
dump("Signing fresh data packet", freshData.getName().toUri())
KeyChain.signWithHmacWithSha256(freshData, key)
if KeyChain.verifyDataWithHmacWithSha256(freshData, key):
dump("Freshly-signed data signature verification: VERIFIED")
else:
dump("Freshly-signed data signature verification: FAILED")
bytesSend = freshData.wireEncode()
print binascii.hexlify(bytes(bytesSend))
try:
nistCharacteristic.write(bytes(bytesSend), True)
except:
print "Exception when trying to write to BLE characteristic."
def SCD_scan_and_connect(is_first=True):
global gTargetDevice
#
# scanning for a while
#
print("SCD--> BLE device scan %sstarted..." %
('re' if not is_first else ''),
flush=True)
tm = tm_s = time.time()
while tm_s - tm < RESCAN_PERIOD:
scanner = Scanner().withDelegate(ScanDelegate())
devices = scanner.scan(SCAN_TIME)
print(
"\nSCD--> BLE device scan completed... [%d] devices are scanned" %
gScannedCount,
flush=True)
#
# check to match BOSCH SCD device identifiers
#
for dev in devices:
matching_count = 0
for (adtype, desc, value) in dev.getScanData():
if adtype == 255 and TARGET_MANUFA_UUID in value:
matching_count += 1
print("SCD--> => found target (AD Type=%d) '%s' is '%s'" %
(adtype, desc, value),
flush=True)
if adtype == 9 and TARGET_DEVICE_NAME in value:
matching_count += 1
print("SCD--> => found target (AD Type=%d) '%s' is '%s'" %
(adtype, desc, value),
flush=True)
if matching_count >= 2:
print("SCD--> => found BOSCH SCD device!")
print(
"SCD--> device address [%s], type=[%s], RSSI=[%d]dB" %
(dev.addr, dev.addrType, dev.rssi),
flush=True)
gTargetDevice = dev
break
if gTargetDevice != None:
break
#
# if none found then exiting
#
if gTargetDevice == None:
tm = time.time()
print("SCD--> no matching device found at [%s]... retry after %d sec..." \
% (datetime.datetime.fromtimestamp(tm).strftime('%Y-%m-%d %H:%M:%S'), RESCAN_INTERVAL), flush=True )
if tm_s - tm >= RESCAN_PERIOD:
print("SCD--> no matching device found... exiting...",
flush=True)
sys.exit(-1)
time.sleep(RESCAN_INTERVAL)
else:
break
#
# connect
#
print("SCD--> connecting [%s], type=[%s]" %
(gTargetDevice.addr, gTargetDevice.addrType),
flush=True)
p = None
retry = 0
while p == None:
try:
p = Peripheral(gTargetDevice.addr, gTargetDevice.addrType)
except:
retry += 1
print(
"SCD--> => BLE device connection error occured [%d] time(s)... retry after 10 sec..."
% retry,
flush=True)
if retry > 30:
print(
"SCD--> => BLE device connection error occured... exiting...",
flush=True)
sys.exit(-1)
time.sleep(10)
#
# should increase MTU##
#
p.setMTU(SCD_MAX_MTU)
#
return p
print "Discovered device", dev.addr
elif isNewData:
print "Received new data from", dev.addr """
"""
def imprime(rssi):
print '\x1b[2J\x1b[1;1H'
print '\n RSSI:',rssi,'dbm' """
RSSI = []
sizeRSSI = 0
start_time = datetime.now()
while sizeRSSI < 600:
scanner = Scanner().withDelegate(ScanDelegate())
devices = scanner.scan(10)
for dev in devices:
if (dev.addr == "7c:01:0a:77:3c:b9"):
#imprime(dev.rssi)
RSSI.append(dev.rssi)
sizeRSSI += 1
#print "Device %s (%s), RSSI=%d dB" % (dev.addr, dev.addrType, dev.rssi)
#for (adtype, desc, value) in dev.getScanData():
# print " %s = %s" % (desc, value)
end_time = datetime.now()
print '\n Experiment time: {} \n'.format(end_time - start_time)
print ' RSSI:', RSSI
print "\n Dados Coletados: ", sizeRSSI
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'
