def getStones(self): r = requests.get('https://my.crownstone.rocks/api/Stones?access_token='+self.accessToken) stones = [] if r.status_code == 200: reply = r.json() for stone in reply: if stone["sphereId"] == self.sphereId: stoneData = { "id": stone["uid"], "name": stone["name"], "cloudId": stone["id"], "address": stone["address"], "type": stone["type"], "dimmingEnabled": stone["dimmingEnabled"], "major": stone["major"], "minor": stone["minor"], "firmwareVersion": stone["firmwareVersion"], } BluenetEventBus.emit(SystemCloudTopics.stoneDownloadedFromCloud, stoneData) stones.append(stone) else: print(r.text) print("Could not get Stones") return stones
def personLeftLocation(self, person, location): BluenetEventBus.emit( CloudTopics.personLeftLocation, { "locationId": location["id"], "name": location["name"], "person": person })
def broadcastState(self): if self.deprecated: return # tell the system this advertisement. BluenetEventBus.emit(SystemTopics.stateUpdate, (self.crownstoneId, self))
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, selector.handleAdvertisement) self.ble.startScanning(scanDuration=scanDuration) BluenetEventBus.unsubscribe(subscriptionId) return selector.getNearest()
def __init__(self): self.stones = {} self.stateManager = StoneStateManager() BluenetEventBus.subscribe(SystemTopics.newCrownstoneFound, self.handleNewStoneFromScan) BluenetEventBus.subscribe(SystemCloudTopics.stoneDownloadedFromCloud, self.handleStoneFromCloud)
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 newPersonInLocation(self, person, location): BluenetEventBus.emit( CloudTopics.personEnteredLocation, { "locationId": location["id"], "name": location["name"], "person": person })
def handleNewStoneFromScan(self, stoneId): if stoneId in self.stones: self.stones[stoneId]["available"] = True else: self.stones[stoneId] = {"available": True} BluenetEventBus.emit(Topics.crownstoneAvailable, self.stones[stoneId])
def parsePayload(self, address, rssi, nameText, valueText): advertisement = Advertisement(address, rssi, nameText, valueText) if self.settings.encryptionEnabled: advertisement.decrypt(self.settings.guestKey) if advertisement.isCrownstoneFamily(): BluenetEventBus.emit(SystemBleTopics.rawAdvertisement, advertisement)
def uartEcho(self, payloadString): # wrap that in a control packet controlPacket = ControlPacket(ControlType.UART_MESSAGE).loadString(payloadString).getPacket() # finally wrap it in an Uart packet uartPacket = UartWrapper(UartTxType.CONTROL, controlPacket).getPacket() # send over uart BluenetEventBus.emit(SystemTopics.uartWriteData, uartPacket)
def emitNewData(self, data): BluenetEventBus.emit(Topics.powerUsageUpdate, { "id": data[0], "powerUsage": data[1].powerUsageReal }) BluenetEventBus.emit(Topics.switchStateUpdate, { "id": data[0], "switchState": data[1].switchState })
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 __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 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 parsePayload(self, address, rssi, nameText, valueText): advertisement = Advertisement(address, rssi, nameText, valueText) if advertisement.serviceData.opCode <= 5: advertisement.decrypt(self.settings.basicKey) elif advertisement.serviceData.opCode >= 7: advertisement.decrypt(self.settings.serviceDataKey) if advertisement.isCrownstoneFamily(): BluenetEventBus.emit(SystemBleTopics.rawAdvertisement, advertisement)
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 checkAdvertisement(self, advertisement): if advertisement.address not in self.trackedCrownstones: self.trackedCrownstones[ advertisement.address] = StoneAdvertisementTracker( lambda: self.removeStone(advertisement.address)) self.trackedCrownstones[advertisement.address].update(advertisement) if self.trackedCrownstones[advertisement.address].verified: BluenetEventBus.emit(Topics.advertisement, advertisement.getDictionary())
def handleStateUpdate(self, data): stoneId = data[0] stoneStatePacket = data[1] if stoneId in self.stones: if self.stones[stoneId]["timestamp"] < stoneStatePacket.timestamp: self.stones[stoneId] = stoneStatePacket.getSummary() self.emitNewData(stoneStatePacket) else: BluenetEventBus.emit(SystemTopics.newCrownstoneFound, stoneId) self.stones[stoneId] = stoneStatePacket.getSummary() self.emitNewData(stoneStatePacket)
def handleAdvertisement(self, advertisement): if "serviceData" not in advertisement: return if advertisement["address"] != self.address: return self.result = not advertisement["serviceData"]["setupMode"] if not self.result and self.waitUntilInRequiredMode: pass else: BluenetEventBus.emit(SystemBleTopics.abortScanning, True)
def process(self): payload = self.buffer[0:len(self.buffer) - CRC_SIZE] calculatedCrc = UartUtil.crc16_ccitt(payload) sourceCrc = Conversion.uint8_array_to_uint16( self.buffer[len(self.buffer) - CRC_SIZE:len(self.buffer)]) if calculatedCrc != sourceCrc: print("WARN: Failed CRC") self.reset() return packet = UartPacket(self.buffer) BluenetEventBus.emit(SystemTopics.uartNewPackage, packet) self.reset()
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 handleStateUpdate(self, data): stoneId = data[0] state = data[1] if stoneId in self.stones: if self.stones[stoneId]["timestampLastSeen"] < state.timestamp: self.stones[stoneId]["timestampLastSeen"] = state.timestamp self.stones[stoneId]["data"] = data[1].getDict() self.emitNewData(data) else: BluenetEventBus.emit(Topics.newCrownstoneFound, data[0]) self.stones[stoneId] = { "timestampLastSeen": state.timestamp, "data": data[1].getDict() } self.emitNewData(data)
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 parsePayload(self, parsedCrownstoneData): advertisement = Advertisement(parsedCrownstoneData.address, parsedCrownstoneData.rssi, parsedCrownstoneData.name, parsedCrownstoneData.valueArr, parsedCrownstoneData.serviceUUID) if advertisement.serviceData.opCode <= 5: advertisement.decrypt(self.settings.basicKey) elif advertisement.serviceData.opCode >= 7: advertisement.decrypt(self.settings.serviceDataKey) print("parsing a packet", advertisement.isCrownstoneFamily()) if advertisement.isCrownstoneFamily(): BluenetEventBus.emit(SystemBleTopics.rawAdvertisement, advertisement)
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 handleAdvertisement(self, advertisement): if "serviceData" not in advertisement: return if self.setupModeOnly and not advertisement["serviceData"]["setupMode"]: return if not self.setupModeOnly and advertisement["serviceData"]["setupMode"]: return if advertisement["rssi"] < self.rssiAtLeast: return self.deviceList.append(advertisement) if self.returnFirstAcceptable: BluenetEventBus.emit(SystemBleTopics.abortScanning, True)
def getPresence(self): r = requests.get('https://my.crownstone.rocks/api/Spheres/' + self.sphereId + '/ownedLocations?filter=%7B%22include%22%3A%22presentPeople%22%7D&access_token=' + self.accessToken) locations = [] if r.status_code == 200: reply = r.json() for location in reply: presentPeople = [] for person in location["presentPeople"]: presentPeople.append({"id": person["id"], "email":person["email"], "name": person["firstName"] + " " + person["lastName"]}) locationData = {"cloudId": location["id"], "id": location["uid"], "name": location["name"], 'presentPeople': presentPeople} locations.append(locationData) BluenetEventBus.emit(SystemCloudTopics.presenceInLocationDownloadedFromCloud, locationData) else: print(r.text) print("Could not get presence") return locations
def __switchCrownstone(self, crownstoneId, value): """ :param crownstoneId: :param value: 0 .. 1 :return: """ # forcibly map the input from [any .. any] to [0 .. 1] correctedValue = min(1,max(0,value)) # create a stone switch state packet to go into the multi switch stoneSwitchPacket = StoneMultiSwitchPacket(crownstoneId, correctedValue, 0, IntentType.MANUAL) # wrap it in a mesh multi switch packet meshMultiSwitchPacket = MeshMultiSwitchPacket(MeshMultiSwitchType.SIMPLE_LIST, [stoneSwitchPacket]).getPacket() # wrap that in a control packet controlPacket = ControlPacket(ControlType.MESH_MULTI_SWITCH).loadByteArray(meshMultiSwitchPacket).getPacket() # finally wrap it in an Uart packet uartPacket = UartWrapper(UartTxType.CONTROL, controlPacket).getPacket() # send over uart BluenetEventBus.emit(SystemTopics.uartWriteData, uartPacket)
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()