def __send_device_info_event(self, connected: bool, serial_number: str, software_version: str): event = messages_pb2.PurpleDropEvent() event.device_info.connected = connected event.device_info.serial_number = serial_number event.device_info.software_version = software_version self.__fire_event(event)
def handler(self, jpeg, transform): image_event = messages_pb2.PurpleDropEvent() transform_event = messages_pb2.PurpleDropEvent() timestamp = time.time() image_event.image.timestamp.seconds = int(timestamp) image_event.image.timestamp.nanos = int((timestamp % 1) * 1e9) image_event.image.image_data = jpeg transform_event.image_transform.timestamp.seconds = int(timestamp) transform_event.image_transform.timestamp.nanos = int( (timestamp % 1) * 1e9) if transform['transform'] is not None: transform_event.image_transform.transform[:] = sum( transform['transform'], []) else: transform_event.image_transform.transform[:] = [] transform_event.image_transform.image_width = transform['image_width'] transform_event.image_transform.image_height = transform[ 'image_height'] self.on_callback(image_event, transform_event)
async def record(uri, filepath, verbose): with open(filepath, 'wb') as f: async with websockets.connect(uri) as ws: while True: raw_event = await ws.recv() if verbose: event = messages_pb2.PurpleDropEvent() event.ParseFromString(raw_event) print(event.WhichOneof('msg')) length_bytes = struct.pack('I', len(raw_event)) f.write(length_bytes) f.write(raw_event)
def next(self): """Consume a message from the stream and return it """ length_bytes = self.fd.read(4) if len(length_bytes) != 4: return None length = struct.unpack("I", length_bytes)[0] msg_data = self.fd.read(length) if len(msg_data) != length: return None event = messages_pb2.PurpleDropEvent() event.ParseFromString(msg_data) return event
def __fire_pinstate_event(self): def create_electrode_group(x): eg = messages_pb2.ElectrodeGroup() eg.electrodes[:] = x.pin_mask eg.setting = x.setting return eg event = messages_pb2.PurpleDropEvent() for g in self.pin_state.drive_groups: event.electrode_state.drive_groups.add(electrodes=g.pin_mask, setting=g.setting) for g in self.pin_state.scan_groups: event.electrode_state.scan_groups.add(electrodes=g.pin_mask, setting=g.setting) self.__fire_event(event)
def __message_callback(self, msg): if isinstance(msg, messages.ActiveCapacitanceMsg): # Active capacitance is always measured with high gain for now self.active_capacitance = self.__calibrate_capacitance( msg.measurement - msg.baseline, CAPGAIN_HIGH) self.active_capacitance_counter += 1 # Throttle the events. 500Hz messages is a lot for the browser to process. # This also means logs don't have a full resolution, and it would be better # if clients could choose what they get if (self.active_capacitance_counter % 10) == 0: cap_event = messages_pb2.PurpleDropEvent() cap_event.active_capacitance.baseline = msg.baseline cap_event.active_capacitance.measurement = msg.measurement cap_event.active_capacitance.calibrated = float( self.active_capacitance) cap_event.active_capacitance.timestamp.CopyFrom( get_pb_timestamp()) self.__fire_event(cap_event) elif isinstance(msg, messages.BulkCapacitanceMsg): if (msg.group_scan != 0): self.group_capacitance_counter += 1 if (self.group_capacitance_counter % 10) == 0: self.raw_group_capacitance = msg.measurements self.calibrated_group_capacitance = [0] * len( self.raw_group_capacitance) for i in range(msg.count): if self.pin_state.scan_groups[i].setting == 0: gain = CAPGAIN_HIGH else: gain = CAPGAIN_LOW self.calibrated_group_capacitance[ i] = self.__calibrate_capacitance( msg.measurements[i], gain) group_event = messages_pb2.PurpleDropEvent() group_event.group_capacitance.timestamp.CopyFrom( get_pb_timestamp()) group_event.group_capacitance.measurements[:] = self.calibrated_group_capacitance group_event.group_capacitance.raw_measurements[:] = self.raw_group_capacitance self.__fire_event(group_event) else: # Scan capacitance measurements are broken up into multiple messages if len(self.raw_scan_capacitance ) < msg.start_index + msg.count: self.raw_scan_capacitance.extend( [0] * (msg.start_index + msg.count - len(self.raw_scan_capacitance))) self.calibrated_scan_capacitance.extend( [0] * (msg.start_index + msg.count - len(self.calibrated_scan_capacitance))) for i in range(msg.count): chan = msg.start_index + i gain = self.scan_gains[chan] self.raw_scan_capacitance[chan] = msg.measurements[i] self.calibrated_scan_capacitance[ chan] = self.__calibrate_capacitance( msg.measurements[i], gain) # Fire event on the last group if msg.start_index + msg.count == 128: bulk_event = messages_pb2.PurpleDropEvent() def make_cap_measurement(raw, calibrated): m = messages_pb2.CapacitanceMeasurement() m.raw = float(raw) m.capacitance = float(calibrated) return m bulk_event.scan_capacitance.measurements.extend([ make_cap_measurement(raw, cal) for (raw, cal) in zip(self.raw_scan_capacitance, self.calibrated_scan_capacitance) ]) bulk_event.scan_capacitance.timestamp.CopyFrom( get_pb_timestamp()) self.__fire_event(bulk_event) elif isinstance(msg, messages.DutyCycleUpdatedMsg): self.duty_cycle_updated_counter += 1 if (self.duty_cycle_updated_counter % 10) == 0: # Update local state of duty cycle self.pin_state.drive_groups[0].duty_cycle = msg.duty_cycle_A self.pin_state.drive_groups[1].duty_cycle = msg.duty_cycle_B # Publish event with new values duty_cycle_event = messages_pb2.PurpleDropEvent() duty_cycle_event.duty_cycle_updated.timestamp.CopyFrom( get_pb_timestamp()) duty_cycle_event.duty_cycle_updated.duty_cycles[:] = [ msg.duty_cycle_A, msg.duty_cycle_B ] self.__fire_event(duty_cycle_event) elif isinstance(msg, messages.HvRegulatorMsg): self.hv_regulator_counter += 1 if (self.hv_regulator_counter % 10) == 0: self.hv_supply_voltage = msg.voltage event = messages_pb2.PurpleDropEvent() event.hv_regulator.voltage = msg.voltage event.hv_regulator.v_target_out = msg.v_target_out event.hv_regulator.timestamp.CopyFrom(get_pb_timestamp()) self.__fire_event(event) elif isinstance(msg, messages.TemperatureMsg): self.temperatures = [float(x) / 100.0 for x in msg.measurements] event = messages_pb2.PurpleDropEvent() event.temperature_control.temperatures[:] = self.temperatures duty_cycles = [] for i in range(len(self.temperatures)): duty_cycles.append(self.duty_cycles.get(i, 0.0)) event.temperature_control.duty_cycles[:] = duty_cycles event.temperature_control.timestamp.CopyFrom(get_pb_timestamp()) self.__fire_event(event)