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)