def check(self):
alerts = super().check()
if self.range_length < 1e-6:
alerts.append(
cb.Warning("range_interval",
"Will only return a single point"))
if self.downsampling_factor not in [1, 2, 4]:
alerts.append(cb.Error("downsampling_factor",
"Must be 1, 2, or 4"))
if self.repetition_mode == __class__.RepetitionMode.SENSOR_DRIVEN:
chunks = self.range_length / 0.06
chunks += 2 if self.mode == Mode.IQ else 0
points_per_chunk = 124 / self.downsampling_factor
if points_per_chunk * chunks > 2048:
alerts.append(
cb.Error("range_interval", "Too large for buffer"))
if self.power_save_mode == __class__.PowerSaveMode.HIBERNATE:
alerts.append(
cb.Error("power_save_mode", "Not supported for this service"))
return alerts
def check(self):
alerts = super().check()
if self.range_length < self._MIN_BIN_SIZE:
alerts.append(cb.Error("range_interval", "Too short"))
elif self.range_length / self.bin_count < self._MIN_BIN_SIZE:
alerts.append(cb.Error("bin_count", "Too high for current range"))
return alerts
def check_sensor_config(self, conf):
alerts = []
if conf.update_rate is None:
alerts.append(configbase.Error("update_rate", "Must be set"))
if not conf.sweeps_per_frame > 3:
alerts.append(configbase.Error("sweeps_per_frame", "Must be > 3"))
return alerts
def check(self):
alerts = super().check()
if self.range_start < (0.06 - 1e-6):
alerts.append(cb.Error("range_interval",
"Start must be >= 0.06 m"))
if self.sampling_mode == __class__.SamplingMode.B:
alerts.append(
cb.Error("sampling_mode", "IQ sampling mode B is removed"))
return alerts
def check(self):
alerts = super().check()
if self.range_start < (0.06 - 1e-6):
alerts.append(cb.Error("range_interval", "Start must be >= 0.06 m"))
return alerts
def check_sensor_config(self, sensor_config):
alerts = []
if sensor_config.update_rate is None:
alerts.append(configbase.Error("update_rate", "Must be set"))
if not sensor_config.noise_level_normalization:
alerts.append(
configbase.Error("noise_level_normalization", "Must be set"))
if self.depth_leak_sample < sensor_config.range_start \
or self.depth_leak_sample > sensor_config.range_end:
alerts.append(
configbase.Error(
"range_interval",
"Leak sample position outside the range interval"))
return alerts
def check(self):
alerts = []
if self.depth_leak_sample >= self.depth_leak_end:
alerts.append(
configbase.Error("depth_leak_sample",
"Must be less than the leak end position"))
return alerts
def check(self):
alerts = super().check()
if self.sampling_mode == __class__.SamplingMode.B:
if self.sweeps_per_frame > 64:
alerts.append(cb.Error("sweeps_per_frame", "Must be < 64 with sampling mode B"))
if self.sweep_rate is not None and self.update_rate is not None:
max_frame_rate = self.sweep_rate / self.sweeps_per_frame
if self.update_rate > max_frame_rate:
alerts.append(cb.Error("sweep_rate", "Too low for current update rate"))
# Pessimistic buffer size check
start_p = int(round(self.range_start / 0.06 - 0.01))
end_p = int(round(self.range_end / 0.06 + 0.01))
sweep_size = (end_p - start_p) // self.downsampling_factor + 1
if sweep_size * self.sweeps_per_frame > 2048:
alerts.append(cb.Error("range_interval", "Too long for buffer"))
return alerts
def check(self):
alerts = []
if self.repetition_mode == __class__.RepetitionMode.SENSOR_DRIVEN:
if self.update_rate is None:
alerts.append(cb.Error("update_rate", "Must be set when sensor driven"))
if self.gain > 0.9:
alerts.append(cb.Warning("gain", "Too high gain causes degradation"))
if self.range_start < self.profile.approx_direct_leakage_length:
alerts.append(cb.Info("range_interval", "Direct leakage might be seen"))
return alerts
def check_sensor_config(self, sensor_config):
alerts = []
if sensor_config.update_rate is None:
alerts.append(configbase.Error("update_rate", "Must be set"))
if not sensor_config.noise_level_normalization:
if self.threshold_type == self.ThresholdType.FIXED:
alerts.append(
configbase.Warning(
"noise_level_normalization",
("Enabling noise level normalization is "
"recommended with Fixed threshold")))
return alerts
def check(self):
alerts = []
if self.repetition_mode == __class__.RepetitionMode.SENSOR_DRIVEN:
msg = "Must be set when sensor driven"
if self.update_rate is None:
alerts.append(cb.Error("update_rate", msg))
if not self.asynchronous_measurement:
alerts.append(cb.Error("asynchronous_measurement", msg))
if self.gain > 0.9:
alerts.append(
cb.Warning("gain", "Too high gain causes degradation"))
if self.range_start < self.profile.approx_direct_leakage_length:
alerts.append(
cb.Info("range_interval", "Direct leakage might be seen"))
if self.power_save_mode == __class__.PowerSaveMode.HIBERNATE:
alerts.append(
cb.Warning("power_save_mode", "Limited hardware support"))
if self.repetition_mode == __class__.RepetitionMode.SENSOR_DRIVEN:
alerts.append(
cb.Error("power_save_mode",
"Unavailable when sensor driven"))
psms = [__class__.PowerSaveMode.HIBERNATE, __class__.PowerSaveMode.OFF]
if self.power_save_mode in psms:
if self.asynchronous_measurement:
msg = "PSM hibernate/off is always synchronous"
alerts.append(cb.Info("asynchronous_measurement", msg))
return alerts
def _update(self, *args, **kwargs):
super()._update(*args, **kwargs)
config = self._get_param_value()
if config.is_loaded:
enabled = config.source == "buffer"
text = "Save" if enabled else "Already saved"
else:
enabled = config.has_buffered
if config.has_buffered:
text = "Use measured"
else:
if self._parent_instance._state == cb.Config.State.LIVE:
text = "Measuring..."
else:
text = "Waiting..."
self.buffer_btn.setEnabled(enabled)
self.buffer_btn.setText(text)
text = "Unload" if config.is_loaded else "Load from file"
self.load_btn.setText(text)
if config.is_loaded:
if config.source == "file":
text = "Loaded {}".format(config.source_file)
else:
text = "Loaded measured data"
else:
text = ""
self.info_label.setText(text)
self.info_label.setVisible(config.is_loaded)
self.use_cb.setEnabled(not config.error)
self.use_cb.setChecked(False if config.error else config.use)
self.use_cb.setVisible(config.is_loaded)
if config.error:
self._set_alert(cb.Error(None, config.error))
else:
self._set_alert(None)
