def __init__(self):
BluenetEventBus.subscribe(SystemBleTopics.rawAdvertisement,
self.checkAdvertisement)
self.tickTimer = None
self._lock = threading.Lock()
self.scheduleTick()
self.trackedCrownstones = {}
def _getNearest(self, setup, rssiAtLeast, scanDuration,
returnFirstAcceptable, validated, addressesToExclude):
addressesToExcludeSet = set()
for data in addressesToExclude:
if isinstance(data, dict):
if "address" in data:
addressesToExcludeSet.add(data["address"].lower())
else:
raise BluenetException(
BluenetError.INVALID_ADDRESS,
"Addresses to Exclude is either an array of addresses (like 'f7:19:a4:ef:ea:f6') or an array of dicts with the field 'address'"
)
else:
addressesToExcludeSet.add(data.lower())
selector = NearestSelector(setup, rssiAtLeast, returnFirstAcceptable,
addressesToExcludeSet)
topic = Topics.advertisement
if not validated:
topic = SystemBleTopics.rawAdvertisement
subscriptionId = BluenetEventBus.subscribe(
topic, lambda advertisement: selector.handleAdvertisement(
advertisement.getDictionary()))
else:
subscriptionId = BluenetEventBus.subscribe(
topic, lambda advertisementData: selector.handleAdvertisement(
advertisementData))
self.ble.startScanning(scanDuration=scanDuration)
BluenetEventBus.unsubscribe(subscriptionId)
return selector.getNearest()
def run(self):
self.eventId = BluenetEventBus.subscribe(SystemTopics.uartWriteData, self.writeToUart)
BluenetEventBus.subscribe(SystemTopics.cleanUp, lambda x: self.stop())
self.parser = UartParser()
self.startReading()
def __init__(self):
self.stones = {}
self.stateManager = StoneStateManager()
BluenetEventBus.subscribe(SystemTopics.newCrownstoneFound,
self.handleNewStoneFromScan)
BluenetEventBus.subscribe(SystemCloudTopics.stoneDownloadedFromCloud,
self.handleStoneFromCloud)
def __init__(self, sphereId):
super().__init__()
self.sphereId = sphereId
self.sphereData = None
self.pendingTimer = None
self.pollingEnabled = False
BluenetEventBus.subscribe(SystemTopics.cleanUp, lambda x: self.stopPollingPresence())
def getCrownstonesByScanning(self, scanDuration=3):
gatherer = Gatherer()
subscriptionIdValidated = BluenetEventBus.subscribe(Topics.advertisement, lambda advertisementData: gatherer.handleAdvertisement(advertisementData, True) )
subscriptionIdAll = BluenetEventBus.subscribe(SystemBleTopics.rawAdvertisement, lambda advertisement: gatherer.handleAdvertisement(advertisement.getDictionary(), False) )
self.ble.startScanning(scanDuration=scanDuration)
BluenetEventBus.unsubscribe(subscriptionIdValidated)
BluenetEventBus.unsubscribe(subscriptionIdAll)
return gatherer.getCollection()
def __init__(self, settings, hciIndex=0, scanBackend = ScanBackends.Bluepy):
self.connectedPeripherals = {}
self.settings = None
self.connectedPeripherals = {}
self.connectedPeripheral = None
self.notificationLoopActive = False
self.notificationResult = None
self.scanningActive = False
self.scanAborted = False
self.subscriptionIds = []
self.validator = Validator()
self.settings = settings
self.hciIndex = hciIndex
self.scanBackend = scanBackend
if self.scanBackend == ScanBackends.Aio:
self.scanner = AioScanner(self.hciIndex).withDelegate(AioScanDelegate(settings))
else:
self.scanner = Scanner(self.hciIndex).withDelegate(ScanDelegate(settings))
self.subscriptionIds.append(BluenetEventBus.subscribe(SystemBleTopics.abortScanning, lambda x: self.abortScanning()))
def __init__(self, settings, hciIndex=0):
self.connectedPeripherals = {}
self.validator = Validator()
self.settings = settings
self.hciIndex = hciIndex
self.scanner = Scanner(self.hciIndex).withDelegate(ScanDelegate())
self.subscriptionIds.append(
BluenetEventBus.subscribe(SystemBleTopics.abortScanning,
lambda x: self.abortScanning()))
def isCrownstoneInNormalMode(self, address, scanDuration=3, waitUntilInRequiredMode=False):
# print("Checking if it is in normal mode, address", address)
checker = NormalModeChecker(address, waitUntilInRequiredMode)
subscriptionId = BluenetEventBus.subscribe(Topics.advertisement, checker.handleAdvertisement)
self.ble.startScanning(scanDuration=scanDuration)
BluenetEventBus.unsubscribe(subscriptionId)
return checker.getResult()
def getRssiAverage(self, address, scanDuration=3):
# print("Checking if it is in normal mode, address", address)
checker = RssiChecker(address)
subscriptionId = BluenetEventBus.subscribe(Topics.advertisement, checker.handleAdvertisement)
self.ble.startScanning(scanDuration=scanDuration)
BluenetEventBus.unsubscribe(subscriptionId)
return checker.getResult()
def getRssiAverage(self, address, scanDuration=3):
checker = RssiChecker(address)
subscriptionId = BluenetEventBus.subscribe(
SystemBleTopics.rawAdvertisement, lambda advertisement: checker.
handleAdvertisement(advertisement.getDictionary()))
self.ble.startScanning(scanDuration=scanDuration)
BluenetEventBus.unsubscribe(subscriptionId)
return checker.getResult()
def _getNearest(self, setup, rssiAtLeast, timeout, returnFirstAcceptable,
validated):
selector = NearestSelector(setup, rssiAtLeast, returnFirstAcceptable)
topic = Topics.advertisement
if not validated:
topic = SystemBleTopics.rawAdvertisement
subscriptionId = BluenetEventBus.subscribe(
topic, selector.handleAdvertisement)
self.ble.startScanning(timeout=timeout)
BluenetEventBus.unsubscribe(subscriptionId)
return selector.getNearest()
def __init__(self):
BluenetEventBus.subscribe(SystemTopics.uartNewPackage, self.parse)
def __init__(self):
self.stateManager = StoneStateManager()
BluenetEventBus.subscribe(
SystemCloudTopics.presenceInLocationDownloadedFromCloud,
self.handlePresenceInLocationFromCloud)
def __init__(self, sphereId, eventBus):
super().__init__(eventBus)
self.sphereId = sphereId
BluenetEventBus.subscribe(SystemTopics.cleanUp,
lambda x: self.stopPollingPresence())
def __init__(self):
BluenetEventBus.subscribe(SystemTopics.stateUpdate,
self.handleStateUpdate)
def __init__(self):
self.presence = {}
BluenetEventBus.subscribe(
SystemCloudTopics.presenceInLocationDownloadedFromCloud,
self.handlePresenceInLocationFromCloud)
