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()
