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)