def broadcastState(self):
if self.deprecated:
return
# tell the system this advertisement.
BluenetEventBus.emit(SystemTopics.stateUpdate,
(self.crownstoneId, self))
def personLeftLocation(self, person, location):
BluenetEventBus.emit(
CloudTopics.personLeftLocation, {
"locationId": location["id"],
"name": location["name"],
"person": person
})
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 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 newPersonInLocation(self, person, location):
BluenetEventBus.emit(
CloudTopics.personEnteredLocation, {
"locationId": location["id"],
"name": location["name"],
"person": person
})
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 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 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 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 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 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 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 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 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 add(self, byte):
# if we have a start token and we are not active
if byte is START_TOKEN:
if self.active:
print("WARN: MULTIPLE START TOKENS")
BluenetEventBus.emit(DevTopics.uartNoise, "multiple start token")
# print("buf:", self.buffer)
self.reset()
return
else:
self.active = True
return
if not self.active:
# print(byte)
return
if byte is ESCAPE_TOKEN:
if self.escapingNextToken:
print("WARN: DOUBLE ESCAPE")
BluenetEventBus.emit(DevTopics.uartNoise, "double escape token")
self.reset()
return
self.escapingNextToken = True
return
# first get the escaping out of the way to avoid any double checks later on
if self.escapingNextToken:
byte ^= BIT_FLIP_MASK
self.escapingNextToken = False
self.buffer.append(byte)
bufferSize = len(self.buffer)
if bufferSize == PREFIX_SIZE:
self.length = Conversion.uint8_array_to_uint16(self.buffer[OPCODE_SIZE:PREFIX_SIZE])
if bufferSize > PREFIX_SIZE:
if bufferSize == (self.length + WRAPPER_SIZE):
self.process()
return
elif bufferSize > self.length + WRAPPER_SIZE:
print("WARN: OVERFLOW")
BluenetEventBus.emit(DevTopics.uartNoise, "overflow")
self.reset()
def _send(self, uartPacket):
# send over uart
BluenetEventBus.emit(SystemTopics.uartWriteData, uartPacket)
def parse(self, dataPacket):
opCode = dataPacket.opCode
if opCode == UartRxType.MESH_STATE_0 or opCode == UartRxType.MESH_STATE_1:
# unpack the mesh packet
meshPacket = MeshStatePacket(dataPacket.payload)
# have each stone in the meshPacket broadcast it's state
for stoneState in meshPacket.stoneStates:
stoneState.broadcastState()
elif opCode == UartRxType.SERVICE_DATA:
serviceData = ServiceDataPacket(dataPacket.payload)
if serviceData.isValid():
BluenetEventBus.emit(DevTopics.newServiceData,
serviceData.getDict())
elif opCode == UartRxType.POWER_LOG_CURRENT:
# type is CurrentSamples
parsedData = CurrentSamplesPacket(dataPacket.payload)
BluenetEventBus.emit(DevTopics.newCurrentData,
parsedData.getDict())
elif opCode == UartRxType.POWER_LOG_VOLTAGE:
# type is VoltageSamplesPacket
parsedData = VoltageSamplesPacket(dataPacket.payload)
BluenetEventBus.emit(DevTopics.newVoltageData,
parsedData.getDict())
elif opCode == UartRxType.POWER_LOG_FILTERED_CURRENT:
# type is CurrentSamples
parsedData = CurrentSamplesPacket(dataPacket.payload)
BluenetEventBus.emit(DevTopics.newFilteredCurrentData,
parsedData.getDict())
elif opCode == UartRxType.POWER_LOG_FILTERED_VOLTAGE:
# type is VoltageSamplesPacket
parsedData = VoltageSamplesPacket(dataPacket.payload)
BluenetEventBus.emit(DevTopics.newFilteredVoltageData,
parsedData.getDict())
elif opCode == UartRxType.POWER_LOG_POWER:
# type is PowerCalculationsPacket
parsedData = PowerCalculationPacket(dataPacket.payload)
BluenetEventBus.emit(DevTopics.newCalculatedPowerData,
parsedData.getDict())
elif opCode == UartRxType.ADC_CONFIG:
# type is PowerCalculationsPacket
parsedData = AdcConfigPacket(dataPacket.payload)
BluenetEventBus.emit(DevTopics.newAdcConfigPacket,
parsedData.getDict())
elif opCode == UartRxType.ASCII_LOG:
stringResult = ""
for byte in dataPacket.payload:
stringResult += chr(byte)
sys.stdout.write("LOG: ")
sys.stdout.write(str(round(time.time(), 3)))
sys.stdout.write(" - ")
sys.stdout.write(stringResult)
else:
print("Unknown OpCode", opCode)
def emitNewData(self, stoneStatePacket):
BluenetEventBus.emit(UsbTopics.newDataAvailable,
stoneStatePacket.getSummary())
def broadcastState(self):
# tell the system this advertisement.
BluenetEventBus.emit(SystemTopics.stateUpdate,
(self.serviceData.crownstoneId, self))
def parse(self, dataPacket):
opCode = dataPacket.opCode
parsedData = None
# print("UART - opCode:", opCode, "payload:", dataPacket.payload)
if opCode == UartRxType.MESH_STATE_0 or opCode == UartRxType.MESH_STATE_1:
# unpack the mesh packet
meshPacket = MeshStatePacket(dataPacket.payload)
# have each stone in the meshPacket broadcast it's state
for stoneState in meshPacket.stoneStates:
stoneState.broadcastState()
elif opCode == UartRxType.SERVICE_DATA:
serviceData = ServiceData(dataPacket.payload)
if serviceData.validData:
BluenetEventBus.emit(DevTopics.newServiceData, serviceData.getDictionary())
elif opCode == UartRxType.CROWNSTONE_ID:
id = Conversion.int8_to_uint8(dataPacket.payload)
BluenetEventBus.emit(DevTopics.ownCrownstoneId, id)
elif opCode == UartRxType.MAC_ADDRESS:
if (len(dataPacket.payload) == 7):
# Bug in old firmware (2.1.4 and lower) sends an extra byte.
addr = Conversion.uint8_array_to_address(dataPacket.payload[0:-1])
else:
addr = Conversion.uint8_array_to_address(dataPacket.payload)
if (addr is not ""):
BluenetEventBus.emit(DevTopics.ownMacAddress, addr)
else:
print("invalid address:", dataPacket.payload)
elif opCode == UartRxType.POWER_LOG_CURRENT:
# type is CurrentSamples
parsedData = CurrentSamplesPacket(dataPacket.payload)
BluenetEventBus.emit(DevTopics.newCurrentData, parsedData.getDict())
elif opCode == UartRxType.POWER_LOG_VOLTAGE:
# type is VoltageSamplesPacket
parsedData = VoltageSamplesPacket(dataPacket.payload)
BluenetEventBus.emit(DevTopics.newVoltageData, parsedData.getDict())
elif opCode == UartRxType.POWER_LOG_FILTERED_CURRENT:
# type is CurrentSamples
parsedData = CurrentSamplesPacket(dataPacket.payload)
BluenetEventBus.emit(DevTopics.newFilteredCurrentData, parsedData.getDict())
elif opCode == UartRxType.POWER_LOG_FILTERED_VOLTAGE:
# type is VoltageSamplesPacket
parsedData = VoltageSamplesPacket(dataPacket.payload)
BluenetEventBus.emit(DevTopics.newFilteredVoltageData, parsedData.getDict())
elif opCode == UartRxType.POWER_LOG_POWER:
# type is PowerCalculationsPacket
parsedData = PowerCalculationPacket(dataPacket.payload)
BluenetEventBus.emit(DevTopics.newCalculatedPowerData, parsedData.getDict())
elif opCode == UartRxType.ADC_CONFIG:
# type is PowerCalculationsPacket
parsedData = AdcConfigPacket(dataPacket.payload)
BluenetEventBus.emit(DevTopics.newAdcConfigPacket, parsedData.getDict())
elif opCode == UartRxType.ADC_RESTART:
BluenetEventBus.emit(DevTopics.adcRestarted, None)
elif opCode == UartRxType.ASCII_LOG:
stringResult = ""
for byte in dataPacket.payload:
stringResult += chr(byte)
logStr = "LOG: %15.3f - %s" % (time.time(), stringResult)
sys.stdout.write(logStr)
elif opCode == UartRxType.UART_MESSAGE:
stringResult = ""
for byte in dataPacket.payload:
stringResult += chr(byte)
# logStr = "LOG: %15.3f - %s" % (time.time(), stringResult)
# print(logStr)
BluenetEventBus.emit(UsbTopics.uartMessage, {"string":stringResult, "data": dataPacket.payload})
else:
print("Unknown OpCode", opCode)
parsedData = None
def parse(self, dataPacket):
opCode = dataPacket.opCode
parsedData = None
# print("UART - opCode:", opCode, "payload:", dataPacket.payload)
if opCode == UartRxType.MESH_SERVICE_DATA:
# data type + service data (15b)
serviceData = ServiceData(dataPacket.payload, unencrypted=True)
statePacket = StoneStatePacket(serviceData)
statePacket.broadcastState()
# if serviceData.validData:
# BluenetEventBus.emit(DevTopics.newServiceData, serviceData.getDictionary())
elif opCode == UartRxType.SERVICE_DATA:
# service data type + device type + data type + service data (15b)
serviceData = ServiceData(dataPacket.payload)
if serviceData.validData:
BluenetEventBus.emit(DevTopics.newServiceData, serviceData.getDictionary())
elif opCode == UartRxType.CROWNSTONE_ID:
id = Conversion.int8_to_uint8(dataPacket.payload)
BluenetEventBus.emit(DevTopics.ownCrownstoneId, id)
elif opCode == UartRxType.MAC_ADDRESS:
if len(dataPacket.payload) == 7:
# Bug in old firmware (2.1.4 and lower) sends an extra byte.
addr = Conversion.uint8_array_to_address(dataPacket.payload[0:-1])
else:
addr = Conversion.uint8_array_to_address(dataPacket.payload)
if addr is not "":
BluenetEventBus.emit(DevTopics.ownMacAddress, addr)
else:
print("invalid address:", dataPacket.payload)
elif opCode == UartRxType.POWER_LOG_CURRENT:
# type is CurrentSamples
parsedData = CurrentSamplesPacket(dataPacket.payload)
BluenetEventBus.emit(DevTopics.newCurrentData, parsedData.getDict())
elif opCode == UartRxType.POWER_LOG_VOLTAGE:
# type is VoltageSamplesPacket
parsedData = VoltageSamplesPacket(dataPacket.payload)
BluenetEventBus.emit(DevTopics.newVoltageData, parsedData.getDict())
elif opCode == UartRxType.POWER_LOG_FILTERED_CURRENT:
# type is CurrentSamples
parsedData = CurrentSamplesPacket(dataPacket.payload)
BluenetEventBus.emit(DevTopics.newFilteredCurrentData, parsedData.getDict())
elif opCode == UartRxType.POWER_LOG_FILTERED_VOLTAGE:
# type is VoltageSamplesPacket
parsedData = VoltageSamplesPacket(dataPacket.payload)
BluenetEventBus.emit(DevTopics.newFilteredVoltageData, parsedData.getDict())
elif opCode == UartRxType.POWER_LOG_POWER:
# type is PowerCalculationsPacket
parsedData = PowerCalculationPacket(dataPacket.payload)
BluenetEventBus.emit(DevTopics.newCalculatedPowerData, parsedData.getDict())
elif opCode == UartRxType.ADC_CONFIG:
# type is PowerCalculationsPacket
parsedData = AdcConfigPacket(dataPacket.payload)
BluenetEventBus.emit(DevTopics.newAdcConfigPacket, parsedData.getDict())
elif opCode == UartRxType.ADC_RESTART:
BluenetEventBus.emit(DevTopics.adcRestarted, None)
elif opCode == UartRxType.ASCII_LOG:
stringResult = ""
for byte in dataPacket.payload:
if byte < 128:
stringResult += chr(byte)
logStr = "LOG: %15.3f - %s" % (time.time(), stringResult)
sys.stdout.write(logStr)
elif opCode == UartRxType.UART_MESSAGE:
stringResult = ""
for byte in dataPacket.payload:
stringResult += chr(byte)
# logStr = "LOG: %15.3f - %s" % (time.time(), stringResult)
# print(logStr)
BluenetEventBus.emit(UsbTopics.uartMessage, {"string":stringResult, "data": dataPacket.payload})
elif opCode == UartRxType.FIRMWARESTATE:
# no need to process this, that's in the test suite.
pass
else:
print("Unknown OpCode", opCode)
parsedData = None
def stop(self):
print("Quitting BluenetLib...")
BluenetEventBus.emit(SystemTopics.cleanUp)
self.running = False
def parsePayload(self, address, rssi, nameText, valueText):
advertisement = Advertisement(address, rssi, nameText, valueText)
if advertisement.isCrownstoneFamily():
BluenetEventBus.emit(SystemBleTopics.rawAdvertisement, advertisement)
