def from_xml(cls, tag: ET.Element, field_types_by_caption=None):
"""
:param tag:
:type field_types_by_caption: dict[str, FieldType]
:return:
"""
field_types_by_caption = dict() if field_types_by_caption is None else field_types_by_caption
name = tag.get("name")
start, end = int(tag.get("start", 0)), int(tag.get("end", 0)) - 1
color_index = int(tag.get("color_index", 0))
result = ProtocolLabel(name=name, start=start, end=end, color_index=color_index)
result.apply_decoding = True if tag.get("apply_decoding", 'True') == "True" else False
result.show = Qt.Checked if Formatter.str2val(tag.get("show", 0), int) else Qt.Unchecked
result.fuzz_me = Qt.Checked if Formatter.str2val(tag.get("fuzz_me", 0), int) else Qt.Unchecked
result.fuzz_values = tag.get("fuzz_values", "").split(",")
result.display_format_index = int(tag.get("display_format_index", 0))
result.auto_created = True if tag.get("auto_created", 'False') == "True" else False
if result.name in field_types_by_caption:
result.field_type = field_types_by_caption[result.name]
else:
result.field_type = None
return result
def from_xml(cls, tag: ET.Element, field_types_by_caption=None):
"""
:param tag:
:type field_types_by_caption: dict[str, FieldType]
:return:
"""
field_types_by_caption = dict() if field_types_by_caption is None else field_types_by_caption
name = tag.get("name")
start, end = int(tag.get("start", 0)), int(tag.get("end", 0)) - 1
color_index = int(tag.get("color_index", 0))
result = ProtocolLabel(name=name, start=start, end=end, color_index=color_index)
result.apply_decoding = True if tag.get("apply_decoding", 'True') == "True" else False
result.show = Qt.Checked if Formatter.str2val(tag.get("show", 0), int) else Qt.Unchecked
result.fuzz_me = Qt.Checked if Formatter.str2val(tag.get("fuzz_me", 0), int) else Qt.Unchecked
result.fuzz_values = tag.get("fuzz_values", "").split(",")
result.auto_created = True if tag.get("auto_created", 'False') == "True" else False
if result.name in field_types_by_caption:
result.field_type = field_types_by_caption[result.name]
else:
result.field_type = None
# set this after result.field_type because this would change display_format_index to field_types default
result.display_format_index = int(tag.get("display_format_index", 0))
result.display_bit_order_index = int(tag.get("display_bit_order_index", 0))
result.display_endianness = tag.get("display_endianness", "big")
return result
def from_xml(tag: ET.Element):
result = Modulator("")
for attrib, value in tag.attrib.items():
if attrib == "index":
continue
elif attrib == "name" or attrib == "modulation_type":
setattr(result, attrib, str(value))
elif attrib == "samples_per_bit" or attrib == "samples_per_symbol":
# samples_per_bit as legacy support for older project files
result.samples_per_symbol = Formatter.str2val(value, int, 100)
elif attrib == "sample_rate":
result.sample_rate = Formatter.str2val(
value, float, 1e6) if value != "None" else None
elif attrib == "param_for_zero":
result.parameters[0] = Formatter.str2val(value, float,
0) # legacy
elif attrib == "param_for_one":
result.parameters[1] = Formatter.str2val(value, float,
100) # legacy
elif attrib == "parameters":
try:
result.parameters = array.array(
"f", map(float, value.split(",")))
except ValueError:
continue
else:
setattr(result, attrib, Formatter.str2val(value, float, 1))
return result
def from_xml(cls, tag: ET.Element, field_types_by_type_id=None):
"""
:param tag:
:type field_types_by_type_id: dict[str, FieldType]
:return:
"""
field_types_by_type_id = dict() if field_types_by_type_id is None else field_types_by_type_id
name = tag.get("name")
start, end = int(tag.get("start", 0)), int(tag.get("end", 0)) - 1
color_index = int(tag.get("color_index", 0))
result = ProtocolLabel(name=name, start=start, end=end, color_index=color_index)
result.apply_decoding = True if tag.get("apply_decoding", 'True') == "True" else False
result.show = Qt.Checked if Formatter.str2val(tag.get("show", 0), int) else Qt.Unchecked
result.fuzz_me = Qt.Checked if Formatter.str2val(tag.get("fuzz_me", 0), int) else Qt.Unchecked
result.fuzz_values = tag.get("fuzz_values", "").split(",")
result.display_format_index = int(tag.get("display_format_index", 0))
result.auto_created = True if tag.get("auto_created", 'False') == "True" else False
type_id = tag.get("type_id", None)
if type_id and type_id in field_types_by_type_id:
result.field_type = field_types_by_type_id[type_id]
else:
result.field_type = None
return result
def test_set_sample_rate(self):
self.assertEqual(Formatter.science_time(self.signal.num_samples / self.signal.sample_rate),
self.dialog.ui.lDuration.text())
self.dialog.ui.dsb_sample_rate.setValue(5e6)
self.assertEqual(self.signal.sample_rate, 5e6)
self.assertEqual(Formatter.science_time(self.signal.num_samples / self.signal.sample_rate),
self.dialog.ui.lDuration.text())
def test_set_sample_rate(self):
self.assertEqual(Formatter.science_time(self.signal.num_samples / self.signal.sample_rate),
self.dialog.ui.lDuration.text())
self.dialog.ui.dsb_sample_rate.setValue(5e6)
self.assertEqual(self.signal.sample_rate, 5e6)
self.assertEqual(Formatter.science_time(self.signal.num_samples / self.signal.sample_rate),
self.dialog.ui.lDuration.text())
def drawBackground(self, painter: QPainter, rect: QRectF):
# freqs = np.fft.fftfreq(len(w), 1 / self.sample_rate)
if self.draw_grid and len(self.frequencies) > 0:
painter.setPen(QPen(painter.pen().color(), 0))
parent_width = self.parent().width() if hasattr(
self.parent(), "width") else 750
view_rect = self.parent().view_rect() if hasattr(
self.parent(), "view_rect") else rect
font_width = self.font_metrics.width(
Formatter.big_value_with_suffix(self.center_freq) + " ")
x_grid_size = int(view_rect.width() / parent_width * font_width)
# x_grid_size = int(0.1 * view_rect.width()) if 0.1 * view_rect.width() > 1 else 1
y_grid_size = 1
x_mid = np.where(self.frequencies == 0)[0]
x_mid = int(x_mid[0]) if len(x_mid) > 0 else 0
left = int(rect.left()) - (int(rect.left()) % x_grid_size)
left = left if left > 0 else 0
top = rect.top() - (rect.top() % y_grid_size)
bottom = rect.bottom() - (rect.bottom() % y_grid_size)
right_border = int(
rect.right()) if rect.right() < len(self.frequencies) else len(
self.frequencies)
x_range = list(range(x_mid, left, -x_grid_size)) + list(
range(x_mid, right_border, x_grid_size))
lines = [QLineF(x, rect.top(), x, bottom) for x in x_range] \
+ [QLineF(rect.left(), y, rect.right(), y) for y in np.arange(top, bottom, y_grid_size)]
painter.drawLines(lines)
scale_x, scale_y = util.calc_x_y_scale(rect, self.parent())
painter.scale(scale_x, scale_y)
counter = -1 # Counter for Label for every second line
for x in x_range:
freq = self.frequencies[x]
counter += 1
if freq != 0 and (counter % 2 !=
0): # Label for every second line
continue
if freq != 0:
prefix = "+" if freq > 0 else ""
value = prefix + Formatter.big_value_with_suffix(freq, 2)
else:
counter = 0
value = Formatter.big_value_with_suffix(6800e6 -
self.center_freq +
self.status_k)
font_width = self.font_metrics.width(value)
painter.drawText(x / scale_x - font_width / 2,
bottom / scale_y, value)
def sample_rate(self, value):
if value > self._max_sample_rate:
err = "{0} sample rate {1}Sps too high. Correcting to {2}Sps".format(
type(self).__name__, Formatter.big_value_with_suffix(value),
Formatter.big_value_with_suffix(self._max_sample_rate))
self.errors.add(err)
logger.warning(err)
value = self._max_sample_rate
if value != self.__sample_rate:
self.__sample_rate = value
self.set_device_sample_rate(value)
def frequency(self, value):
if value > self._max_frequency:
err = "{0} frequency {1}Hz too high. Correcting to {2}Hz".format(
type(self).__name__, Formatter.big_value_with_suffix(value),
Formatter.big_value_with_suffix(self._max_frequency))
self.errors.add(err)
logger.warning(err)
value = self._max_frequency
if value != self.__frequency:
self.__frequency = value
self.set_device_frequency(value)
def bandwidth(self, value):
if value > self._max_bandwidth:
err = "{0} bandwidth {1}Hz too high. Correcting to {2}Hz".format(type(self).__name__,
Formatter.big_value_with_suffix(value),
Formatter.big_value_with_suffix(self._max_bandwidth))
self.errors.add(err)
logger.warning(err)
value = self._max_bandwidth
if value != self.__bandwidth:
self.__bandwidth = value
if self.is_open:
self.set_device_bandwidth(value)
def drawBackground(self, painter: QPainter, rect: QRectF):
# freqs = np.fft.fftfreq(len(w), 1 / self.sample_rate)
if self.draw_grid and len(self.frequencies) > 0:
painter.setPen(QPen(painter.pen().color(), Qt.FlatCap))
parent_width = self.parent().width() if hasattr(self.parent(), "width") else 750
view_rect = self.parent().view_rect() if hasattr(self.parent(), "view_rect") else rect
font_width = self.font_metrics.width(Formatter.big_value_with_suffix(self.center_freq) + " ")
x_grid_size = int(view_rect.width() / parent_width * font_width)
# x_grid_size = int(0.1 * view_rect.width()) if 0.1 * view_rect.width() > 1 else 1
y_grid_size = view_rect.height() / parent_width * font_width
x_mid = np.where(self.frequencies == 0)[0]
x_mid = int(x_mid[0]) if len(x_mid) > 0 else 0
left = int(rect.left()) - (int(rect.left()) % x_grid_size)
left = left if left > 0 else 0
top = rect.top() - (rect.top() % y_grid_size)
bottom = rect.bottom() - (rect.bottom() % y_grid_size)
right_border = int(rect.right()) if rect.right() < len(self.frequencies) else len(self.frequencies)
x_range = list(range(x_mid, left, -x_grid_size)) + list(range(x_mid, right_border, x_grid_size))
lines = [QLineF(x, rect.top(), x, bottom) for x in x_range] \
+ [QLineF(rect.left(), y, rect.right(), y) for y in np.arange(top, bottom, y_grid_size)]
painter.drawLines(lines)
scale_x = view_rect.width() / parent_width
scale_y = view_rect.height() / parent_width
painter.scale(scale_x, scale_y)
font_height = self.font_metrics.height()
counter = -1 # Counter for Label for every second line
for x in x_range:
freq = self.frequencies[x]
counter += 1
if freq != 0 and (counter % 2 != 0): # Label for every second line
continue
if freq != 0:
prefix = "+" if freq > 0 else ""
value = prefix+Formatter.big_value_with_suffix(freq, 2)
else:
counter = 0
value = Formatter.big_value_with_suffix(self.center_freq)
font_width = self.font_metrics.width(value)
painter.drawText(x / scale_x - font_width / 2,
bottom / scale_y + font_height, value)
def add_fuzz_value(self):
cur_val = self.fuzz_values[-1]
format_string = "{0:0" + str(len(cur_val)) + "b}"
maximum = 2 ** len(cur_val)
cur_val = format_string.format((int(str(Formatter.str2val(cur_val, int)), 2) + 1) % maximum)
self.fuzz_values.append(cur_val)
def view_to_string(self,
view: int,
decoded: bool,
show_pauses=True,
sample_rate: float = None) -> str:
"""
:param view: 0 - Bits ## 1 - Hex ## 2 - ASCII
"""
if view == 0:
proto = self.decoded_bits_str if decoded else self.plain_bits_str
elif view == 1:
proto = self.decoded_hex_str if decoded else self.plain_hex_str
elif view == 2:
proto = self.decoded_ascii_str if decoded else self.plain_ascii_str
else:
return None
if show_pauses:
if sample_rate:
return '%s [Pause: %s]' % (
proto, Formatter.science_time(self.pause / sample_rate))
else:
return '%s [Pause: %d samples]' % (proto, self.pause)
else:
return proto
def refresh_pause_list(self):
self.ui.lWPauses.clear()
fmt_str = "Pause ({1:d}-{2:d}) <{0:d} samples ({3})>"
for i, pause in enumerate(self.table_model.protocol.pauses):
sr = self.__get_modulator_of_message(self.table_model.protocol.messages[i]).sample_rate
item = fmt_str.format(pause, i + 1, i + 2, Formatter.science_time(pause / sr))
self.ui.lWPauses.addItem(item)
def update_view(self):
try:
self.ui.sliderYscale.setValue(int(self.graphics_view.transform().m22()))
except AttributeError:
return
txt = self.ui.txtEditErrors.toPlainText()
new_messages = self.device.read_messages()
self.__parse_error_messages(new_messages)
if len(new_messages) > 1:
self.ui.txtEditErrors.setPlainText(txt + new_messages)
self.ui.lSamplesCaptured.setText(Formatter.big_value_with_suffix(self.device.current_index, decimals=1))
self.ui.lSignalSize.setText(locale.format_string("%.2f", (8 * self.device.current_index) / (1024 ** 2)))
self.ui.lTime.setText(locale.format_string("%.2f", self.device.current_index / self.device.sample_rate))
if self.is_rx and self.device.data is not None and len(self.device.data) > 0:
self.ui.labelReceiveBufferFull.setText("{0}%".format(int(100 * self.device.current_index /
len(self.device.data))))
if self.device.current_index == 0:
return False
return True
def refresh_pause_list(self):
self.ui.lWPauses.clear()
fmt_str = "Pause ({1:d}-{2:d}) <{0:d} samples ({3})>"
for i, pause in enumerate(self.table_model.protocol.pauses):
sr = self.modulators[self.table_model.protocol.blocks[i].modulator_indx].sample_rate
item = fmt_str.format(pause, i + 1, i + 2, Formatter.science_time(pause / sr))
self.ui.lWPauses.addItem(item)
def on_save_clicked(self):
data = self.device.data[:self.device.current_index]
dev = self.device
big_val = Formatter.big_value_with_suffix
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
initial_name = "{0}-{1}-{2}Hz-{3}Sps".format(dev.name, timestamp,
big_val(dev.frequency),
big_val(dev.sample_rate))
if dev.bandwidth_is_adjustable:
initial_name += "-{}Hz.wav".format(big_val(dev.bandwidth))
initial_name = initial_name.replace(
Formatter.local_decimal_seperator(), "_").replace("_000", "")
FileOperator.save_data(data,
initial_name,
sample_rate=20e6,
long_record=True)
# filename = FileOperator.save_data_dialog(initial_name, data,
# sample_rate=dev.sample_rate)
# filename = self.recorded_files
self.already_saved = True
# if filename is not None and filename not in self.recorded_files:
# self.recorded_files.append(filename)
self.close()
def from_xml(tag: ET.Element):
result = Modulator("")
for attrib, value in tag.attrib.items():
if attrib == "index":
continue
elif attrib == "name":
setattr(result, attrib, str(value))
elif attrib == "modulation_type":
setattr(result, attrib, Formatter.str2val(value, int, 0))
elif attrib == "samples_per_bit":
setattr(result, attrib, Formatter.str2val(value, int, 100))
elif attrib == "sample_rate":
result.sample_rate = Formatter.str2val(value, float, 1e6) if value != "None" else None
else:
setattr(result, attrib, Formatter.str2val(value, float, 1))
return result
def update_view(self):
try:
self.ui.sliderYscale.setValue(
int(self.graphics_view.transform().m22()))
except AttributeError:
return
txt = self.ui.txtEditErrors.toPlainText()
new_messages = self.device.read_messages()
self.__parse_error_messages(new_messages)
if len(new_messages) > 1:
self.ui.txtEditErrors.setPlainText(txt + new_messages)
self.ui.lSamplesCaptured.setText(
Formatter.big_value_with_suffix(self.device.current_index,
decimals=1))
self.ui.lSignalSize.setText(
locale.format_string("%.2f Мб",
(8 * self.device.current_index) / (1024**2)))
self.ui.lTime.setText(
locale.format_string(
"%.2f с", self.device.current_index / self.device.sample_rate))
# if self.is_rx and self.device.data is not None and len(self.device.data) > 0:
# self.ui.labelReceiveBufferFull.setText("{0}%".format(int(100 * self.device.current_index /
# len(self.device.data))))
if self.device.current_index == 0:
return False
return True
def draw_frequency_marker(self, x_pos, frequency):
if frequency is None:
self.clear_frequency_marker()
return
y1 = self.sceneRect().y()
y2 = self.sceneRect().y() + self.sceneRect().height()
if self.frequency_marker is None:
pen = QPen(constants.LINECOLOR, 0)
self.frequency_marker = [None, None]
self.frequency_marker[0] = self.addLine(x_pos, y1, x_pos, y2, pen)
self.frequency_marker[1] = self.addSimpleText("")
self.frequency_marker[1].setBrush(QBrush(constants.LINECOLOR))
font = QFont()
font.setBold(True)
font.setPointSize(int(font.pointSize() * 1.25)+1)
self.frequency_marker[1].setFont(font)
self.frequency_marker[0].setLine(x_pos, y1, x_pos, y2)
scale_x, scale_y = self.__calc_x_y_scale(self.sceneRect())
self.frequency_marker[1].setTransform(QTransform.fromScale(scale_x, scale_y), False)
self.frequency_marker[1].setText("Tune to " + Formatter.big_value_with_suffix(frequency, decimals=3))
font_metric = QFontMetrics(self.frequency_marker[1].font())
text_width = font_metric.width("Tune to") * scale_x
text_width += (font_metric.width(" ") * scale_x) / 2
self.frequency_marker[1].setPos(x_pos-text_width, 0.95*y1)
def draw_frequency_marker(self, x_pos, frequency):
if frequency is None:
self.clear_frequency_marker()
return
y1 = self.sceneRect().y()
y2 = self.sceneRect().y() + self.sceneRect().height()
if self.frequency_marker is None:
pen = QPen(constants.LINECOLOR, 0)
self.frequency_marker = [None, None]
self.frequency_marker[0] = self.addLine(x_pos, y1, x_pos, y2, pen)
self.frequency_marker[1] = self.addSimpleText("")
self.frequency_marker[1].setBrush(QBrush(constants.LINECOLOR))
font = QFont()
font.setBold(True)
font.setPointSize(int(font.pointSize() * 1.25)+1)
self.frequency_marker[1].setFont(font)
self.frequency_marker[0].setLine(x_pos, y1, x_pos, y2)
scale_x, scale_y = util.calc_x_y_scale(self.sceneRect(), self.parent())
self.frequency_marker[1].setTransform(QTransform.fromScale(scale_x, scale_y), False)
self.frequency_marker[1].setText("Tune to " + Formatter.big_value_with_suffix(frequency, decimals=3))
font_metric = QFontMetrics(self.frequency_marker[1].font())
text_width = font_metric.width("Tune to") * scale_x
text_width += (font_metric.width(" ") * scale_x) / 2
self.frequency_marker[1].setPos(x_pos-text_width, 0.95*y1)
def add_fuzz_value(self):
cur_val = self.fuzz_values[-1]
format_string = "{0:0" + str(len(cur_val)) + "b}"
maximum = 2 ** len(cur_val)
cur_val = format_string.format((int(str(Formatter.str2val(cur_val, int)), 2) + 1) % maximum)
self.fuzz_values.append(cur_val)
def update_number_selected_samples(self):
self.ui.lNumSelectedSamples.setText(str(abs(int(self.ui.gvSignal.selection_area.width))))
self.__set_duration()
sel_messages = self.ui.gvSignal.selected_messages
if len(sel_messages) == 1:
self.ui.labelRSSI.setText("RSSI: {}".format(Formatter.big_value_with_suffix(sel_messages[0].rssi)))
else:
self.ui.labelRSSI.setText("")
def test_insert_sine_plugin(self):
insert_sine_plugin = self.sframe.ui.gvSignal.insert_sine_plugin
num_samples = 10000
tests.utils_testing.short_wait()
dialog = insert_sine_plugin.get_insert_sine_dialog(
original_data=self.signal.data,
position=2000,
sample_rate=self.signal.sample_rate,
num_samples=num_samples)
graphics_view = dialog.graphicsViewSineWave # type: ZoomableGraphicView
while not dialog.doubleSpinBoxAmplitude.isEnabled():
tests.utils_testing.short_wait()
self.assertEqual(int(graphics_view.sceneRect().width()),
self.signal.num_samples + num_samples)
self.assertEqual(insert_sine_plugin.insert_indicator.rect().width(),
num_samples)
self.assertEqual(insert_sine_plugin.insert_indicator.rect().x(), 2000)
dialog.doubleSpinBoxAmplitude.setValue(0.1)
dialog.doubleSpinBoxAmplitude.editingFinished.emit()
self.assertEqual(insert_sine_plugin.amplitude, 0.1)
while not dialog.doubleSpinBoxAmplitude.isEnabled():
tests.utils_testing.short_wait()
dialog.doubleSpinBoxFrequency.setValue(1e6)
dialog.doubleSpinBoxFrequency.editingFinished.emit()
self.assertEqual(insert_sine_plugin.frequency, 1e6)
while not dialog.doubleSpinBoxAmplitude.isEnabled():
tests.utils_testing.short_wait()
dialog.doubleSpinBoxPhase.setValue(100)
dialog.doubleSpinBoxPhase.editingFinished.emit()
self.assertEqual(insert_sine_plugin.phase, 100)
while not dialog.doubleSpinBoxAmplitude.isEnabled():
tests.utils_testing.short_wait()
dialog.doubleSpinBoxSampleRate.setValue(2e6)
dialog.doubleSpinBoxSampleRate.editingFinished.emit()
self.assertEqual(insert_sine_plugin.sample_rate, 2e6)
while not dialog.doubleSpinBoxAmplitude.isEnabled():
tests.utils_testing.short_wait()
dialog.doubleSpinBoxNSamples.setValue(0.5e6)
dialog.doubleSpinBoxNSamples.editingFinished.emit()
self.assertEqual(insert_sine_plugin.num_samples, 0.5e6)
while not dialog.doubleSpinBoxAmplitude.isEnabled():
tests.utils_testing.short_wait()
sep = Formatter.local_decimal_seperator()
self.assertEqual(dialog.lineEditTime.text(), "250" + sep + "000m")
def __set_duration(self): # On Signal Sample Rate changed
try:
num_samples = int(self.ui.lNumSelectedSamples.text())
except ValueError:
return
if self.signal:
t = num_samples / self.signal.sample_rate
self.ui.lDuration.setText(Formatter.science_time(t))
def mouseMoveEvent(self, event: QMouseEvent):
if isinstance(self.scene(), GridScene):
freq = self.scene().get_freq_for_pos(
int(self.mapToScene(event.pos()).x()))
if freq is not None:
QToolTip.showText(
self.mapToGlobal(event.pos()),
"Tune to:" + Formatter.big_value_with_suffix(freq), None,
QRect(), 10000)
def from_xml(self,
tag: ET.Element,
participants,
decoders=None,
message_types=None):
super().from_xml(tag, participants, decoders, message_types)
self.destination = Participant.find_matching(
tag.get("destination_id", ""), participants)
self.repeat = Formatter.str2val(tag.get("repeat", "1"), int, 1)
def __set_selected_bandwidth(self):
try:
num_samples = int(self.ui.lNumSelectedSamples.text())
except ValueError:
return
if self.ui.gvSpectrogram.height_spectrogram and self.signal:
bw = (num_samples / self.ui.gvSpectrogram.height_spectrogram) * self.signal.sample_rate
self.ui.lDuration.setText(Formatter.big_value_with_suffix(bw) + "Hz")
def __set_duration(self): # On Signal Sample Rate changed
try:
num_samples = int(self.ui.lNumSelectedSamples.text())
except ValueError:
return
if self.signal:
t = num_samples / self.signal.sample_rate
self.ui.lDuration.setText(Formatter.science_time(t))
def test_insert_sine_plugin(self):
insert_sine_plugin = self.sframe.ui.gvSignal.insert_sine_plugin
num_samples = 10000
dialog = insert_sine_plugin.get_insert_sine_dialog(
original_data=self.sframe.signal.iq_array.data,
position=2000,
sample_rate=self.sframe.signal.sample_rate,
num_samples=num_samples)
graphics_view = dialog.graphicsViewSineWave # type: ZoomableGraphicView
self.__wait_for_spinbox_enabled(dialog)
self.assertEqual(int(graphics_view.sceneRect().width()),
self.sframe.signal.num_samples + num_samples)
self.assertEqual(insert_sine_plugin.insert_indicator.rect().width(),
num_samples)
self.assertEqual(insert_sine_plugin.insert_indicator.rect().x(), 2000)
dialog.doubleSpinBoxAmplitude.setValue(0.1)
dialog.doubleSpinBoxAmplitude.editingFinished.emit()
self.assertEqual(insert_sine_plugin.amplitude, 0.1)
self.__wait_for_spinbox_enabled(dialog)
dialog.doubleSpinBoxFrequency.setValue(1e6)
dialog.doubleSpinBoxFrequency.editingFinished.emit()
self.assertEqual(insert_sine_plugin.frequency, 1e6)
self.__wait_for_spinbox_enabled(dialog)
dialog.doubleSpinBoxPhase.setValue(100)
dialog.doubleSpinBoxPhase.editingFinished.emit()
self.assertEqual(insert_sine_plugin.phase, 100)
self.__wait_for_spinbox_enabled(dialog)
dialog.doubleSpinBoxSampleRate.setValue(2e6)
dialog.doubleSpinBoxSampleRate.editingFinished.emit()
self.assertEqual(insert_sine_plugin.sample_rate, 2e6)
self.__wait_for_spinbox_enabled(dialog)
dialog.doubleSpinBoxNSamples.setValue(0.5e6)
dialog.doubleSpinBoxNSamples.editingFinished.emit()
self.assertEqual(insert_sine_plugin.num_samples, 0.5e6)
self.__wait_for_spinbox_enabled(dialog)
sep = Formatter.local_decimal_seperator()
self.assertEqual(dialog.lineEditTime.text(), "250" + sep + "000m")
# Close the dialog via finished
dialog.finished.emit(0)
QApplication.instance().processEvents()
QTest.qWait(self.CLOSE_TIMEOUT)
def refresh_pause_list(self):
self.ui.lWPauses.clear()
fmt_str = "Pause ({1:d}-{2:d}) <{0:d} samples ({3})>"
for i, pause in enumerate(self.table_model.protocol.pauses):
sr = self.__get_modulator_of_message(self.table_model.protocol.messages[i]).sample_rate
item = fmt_str.format(pause, i + 1, i + 2, Formatter.science_time(pause / sr))
self.ui.lWPauses.addItem(item)
self.refresh_estimated_time()
def from_xml(cls, tag: ET.Element, field_types_by_caption=None):
"""
:param tag:
:type field_types_by_caption: dict[str, FieldType]
:return:
"""
label_tag = tag.find("label")
if label_tag is not None:
label = ProtocolLabel.from_xml(label_tag, field_types_by_caption)
else:
label = ChecksumLabel.from_xml(tag.find("checksum_label"), field_types_by_caption)
result = SimulatorProtocolLabel(label)
result.value_type_index = Formatter.str2val(tag.get("value_type_index", "0"), int)
result.external_program = tag.get("external_program", "")
result.formula = tag.get("formula", "")
result.random_min = Formatter.str2val(tag.get("random_min", "0"), int)
result.random_max = Formatter.str2val(tag.get("random_max", str(label.fuzz_maximum-1)), int)
return result
def update_number_selected_samples(self):
self.ui.lNumSelectedSamples.setText(str(abs(int(self.ui.gvSignal.selection_area.width))))
self.__set_duration()
try:
sel_messages = self.ui.gvSignal.selected_messages
except AttributeError:
sel_messages = []
if len(sel_messages) == 1:
self.ui.labelRSSI.setText("RSSI: {}".format(Formatter.big_value_with_suffix(sel_messages[0].rssi)))
else:
self.ui.labelRSSI.setText("")
def get_receive_buffer_size(resume_on_full_receive_buffer: bool, spectrum_mode: bool) -> int:
if resume_on_full_receive_buffer:
if spectrum_mode:
num_samples = constants.SPECTRUM_BUFFER_SIZE
else:
num_samples = constants.SNIFF_BUFFER_SIZE
else:
# Take 60% of avail memory
threshold = constants.SETTINGS.value('ram_threshold', 0.6, float)
num_samples = threshold * (psutil.virtual_memory().available / 8)
logger.info("Initializing receive buffer with size {0}B".format(Formatter.big_value_with_suffix(num_samples*8)))
return int(num_samples)
def from_xml(cls, tag: ET.Element, field_types_by_caption=None):
"""
:param tag:
:type field_types_by_caption: dict[str, FieldType]
:return:
"""
label_tag = tag.find("label")
if label_tag is not None:
label = ProtocolLabel.from_xml(label_tag, field_types_by_caption)
else:
label = ChecksumLabel.from_xml(tag.find("checksum_label"),
field_types_by_caption)
result = SimulatorProtocolLabel(label)
result.value_type_index = Formatter.str2val(
tag.get("value_type_index", "0"), int)
result.external_program = tag.get("external_program", "")
result.formula = tag.get("formula", "")
result.random_min = Formatter.str2val(tag.get("random_min", "0"), int)
result.random_max = Formatter.str2val(
tag.get("random_max", str(label.fuzz_maximum - 1)), int)
return result
def not_enough_ram_for_sending_precache(memory_size_bytes):
w = QWidget()
if memory_size_bytes:
msg = "Precaching all your modulated data would take <b>{0}B</b> of memory, " \
"which does not fit into your RAM.<br>".format(Formatter.big_value_with_suffix(memory_size_bytes))
else:
msg = ""
msg += "Sending will be done in <b>continuous mode</b>.<br><br>" \
"This means, modulation will be performed live during sending.<br><br>" \
"If you experience problems, " \
"consider sending less messages or upgrade your RAM."
QMessageBox.information(w, w.tr("Entering continuous send mode"), w.tr(msg))
def on_save_clicked(self):
data = self.device.data[:self.device.current_index]
dev = self.device
big_val = Formatter.big_value_with_suffix
initial_name = "{0} {1}Hz {2}Sps {3}Hz.complex".format(dev.name, big_val(dev.frequency),
big_val(dev.sample_rate),
big_val(dev.bandwidth)).replace(
Formatter.local_decimal_seperator(), "_").replace("_000", "")
filename = FileOperator.save_data_dialog(initial_name, data, parent=self)
self.already_saved = True
if filename is not None and filename not in self.recorded_files:
self.recorded_files.append(filename)
def not_enough_ram_for_sending_precache(memory_size_bytes):
w = QWidget()
if memory_size_bytes:
msg = "Precaching all your modulated data would take <b>{0}B</b> of memory, " \
"which does not fit into your RAM.<br>".format(Formatter.big_value_with_suffix(memory_size_bytes))
else:
msg = ""
msg += "Sending will be done in <b>continuous mode</b>.<br><br>" \
"This means, modulation will be performed live during sending.<br><br>" \
"If you experience problems, " \
"consider sending less messages or upgrade your RAM."
QMessageBox.information(w, w.tr("Entering continuous send mode"),
w.tr(msg))
def on_save_clicked(self):
data = self.device.data[:self.device.current_index]
dev = self.device
big_val = Formatter.big_value_with_suffix
initial_name = "{0}-{1}Hz-{2}Sps".format(dev.name, big_val(dev.frequency), big_val(dev.sample_rate))
if dev.bandwidth_is_adjustable:
initial_name += "-{}Hz".format(big_val(dev.bandwidth))
initial_name = initial_name.replace(Formatter.local_decimal_seperator(), "_").replace("_000", "")
filename = FileOperator.save_data_dialog(initial_name + ".complex", data, parent=self)
self.already_saved = True
if filename is not None and filename not in self.recorded_files:
self.recorded_files.append(filename)
def update_number_selected_samples(self):
if self.spectrogram_is_active:
self.ui.lNumSelectedSamples.setText(str(abs(int(self.ui.gvSpectrogram.selection_area.length))))
self.__set_selected_bandwidth()
return
else:
self.ui.lNumSelectedSamples.setText(str(abs(int(self.ui.gvSignal.selection_area.length))))
self.__set_duration()
try:
sel_messages = self.ui.gvSignal.selected_messages
except AttributeError:
sel_messages = []
if len(sel_messages) == 1:
self.ui.labelRSSI.setText("RSSI: {}".format(Formatter.big_value_with_suffix(sel_messages[0].rssi)))
else:
self.ui.labelRSSI.setText("")
def get_receive_buffer_size(resume_on_full_receive_buffer: bool,
spectrum_mode: bool) -> int:
if resume_on_full_receive_buffer:
if spectrum_mode:
num_samples = constants.SPECTRUM_BUFFER_SIZE
else:
num_samples = constants.SNIFF_BUFFER_SIZE
else:
# Take 60% of avail memory
threshold = constants.SETTINGS.value('ram_threshold', 0.6, float)
num_samples = threshold * (psutil.virtual_memory().available / 8)
# Do not let it allocate too much on 32 bit
if 8 * num_samples > sys.maxsize // 2:
num_samples = sys.maxsize // (8 * 2)
logger.info("Correcting buffer size to {}".format(num_samples))
logger.info("Initializing receive buffer with size {0}B".format(
Formatter.big_value_with_suffix(num_samples * 8)))
return int(num_samples)
def get_receive_buffer_size(resume_on_full_receive_buffer: bool, spectrum_mode: bool) -> int:
if SettingsProxy.OVERWRITE_RECEIVE_BUFFER_SIZE:
return SettingsProxy.OVERWRITE_RECEIVE_BUFFER_SIZE
if resume_on_full_receive_buffer:
if spectrum_mode:
num_samples = constants.SPECTRUM_BUFFER_SIZE
else:
num_samples = constants.SNIFF_BUFFER_SIZE
else:
# Take 60% of avail memory
threshold = constants.SETTINGS.value('ram_threshold', 0.6, float)
num_samples = threshold * (psutil.virtual_memory().available / 8)
# Do not let it allocate too much memory on 32 bit
if 8 * 2 * num_samples > sys.maxsize:
num_samples = sys.maxsize // (8 * 2 * 1.5)
logger.info("Correcting buffer size to {}".format(num_samples))
logger.info("Allocate receive buffer with {0}B".format(Formatter.big_value_with_suffix(num_samples * 8)))
return int(num_samples)
def on_save_clicked(self):
data = self.device.data[:self.device.current_index]
dev = self.device
big_val = Formatter.big_value_with_suffix
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
initial_name = "{0}-{1}-{2}Hz-{3}Sps".format(dev.name, timestamp,
big_val(dev.frequency),
big_val(dev.sample_rate))
if dev.bandwidth_is_adjustable:
initial_name += "-{}Hz".format(big_val(dev.bandwidth))
initial_name = initial_name.replace(
Formatter.local_decimal_seperator(), "_").replace("_000", "")
filename = FileOperator.ask_signal_file_name_and_save(
initial_name, data, sample_rate=dev.sample_rate, parent=self)
self.already_saved = True
if filename is not None and filename not in self.recorded_files:
self.recorded_files.append(filename)
def get_receive_buffer_size(resume_on_full_receive_buffer: bool, spectrum_mode: bool) -> int:
if OVERWRITE_RECEIVE_BUFFER_SIZE:
return OVERWRITE_RECEIVE_BUFFER_SIZE
if resume_on_full_receive_buffer:
if spectrum_mode:
num_samples = SPECTRUM_BUFFER_SIZE
else:
num_samples = SNIFF_BUFFER_SIZE
else:
# Take 60% of avail memory
threshold = read('ram_threshold', 0.6, float)
num_samples = threshold * (psutil.virtual_memory().available / 8)
# Do not let it allocate too much memory on 32 bit
if 8 * 2 * num_samples > sys.maxsize:
num_samples = sys.maxsize // (8 * 2 * 1.5)
logger.info("Correcting buffer size to {}".format(num_samples))
logger.info("Allocate receive buffer with {0}B".format(Formatter.big_value_with_suffix(num_samples * 8)))
return int(num_samples)
def caption(self):
return "Sleep for " + Formatter.science_time(self.sleep_time)
def test_insert_sine_plugin(self):
insert_sine_plugin = self.sframe.ui.gvSignal.insert_sine_plugin
num_samples = 10000
dialog = insert_sine_plugin.get_insert_sine_dialog(original_data=self.sframe.signal.data,
position=2000,
sample_rate=self.sframe.signal.sample_rate,
num_samples=num_samples)
graphics_view = dialog.graphicsViewSineWave # type: ZoomableGraphicView
while not dialog.doubleSpinBoxAmplitude.isEnabled():
QApplication.instance().processEvents()
QTest.qWait(10)
self.assertEqual(int(graphics_view.sceneRect().width()), self.sframe.signal.num_samples + num_samples)
self.assertEqual(insert_sine_plugin.insert_indicator.rect().width(), num_samples)
self.assertEqual(insert_sine_plugin.insert_indicator.rect().x(), 2000)
dialog.doubleSpinBoxAmplitude.setValue(0.1)
dialog.doubleSpinBoxAmplitude.editingFinished.emit()
self.assertEqual(insert_sine_plugin.amplitude, 0.1)
while not dialog.doubleSpinBoxAmplitude.isEnabled():
self.app.processEvents()
QTest.qWait(10)
dialog.doubleSpinBoxFrequency.setValue(1e6)
dialog.doubleSpinBoxFrequency.editingFinished.emit()
self.assertEqual(insert_sine_plugin.frequency, 1e6)
while not dialog.doubleSpinBoxAmplitude.isEnabled():
self.app.processEvents()
QTest.qWait(10)
dialog.doubleSpinBoxPhase.setValue(100)
dialog.doubleSpinBoxPhase.editingFinished.emit()
self.assertEqual(insert_sine_plugin.phase, 100)
while not dialog.doubleSpinBoxAmplitude.isEnabled():
self.app.processEvents()
QTest.qWait(10)
dialog.doubleSpinBoxSampleRate.setValue(2e6)
dialog.doubleSpinBoxSampleRate.editingFinished.emit()
self.assertEqual(insert_sine_plugin.sample_rate, 2e6)
while not dialog.doubleSpinBoxAmplitude.isEnabled():
self.app.processEvents()
QTest.qWait(10)
dialog.doubleSpinBoxNSamples.setValue(0.5e6)
dialog.doubleSpinBoxNSamples.editingFinished.emit()
self.assertEqual(insert_sine_plugin.num_samples, 0.5e6)
while not dialog.doubleSpinBoxAmplitude.isEnabled():
self.app.processEvents()
QTest.qWait(10)
sep = Formatter.local_decimal_seperator()
self.assertEqual(dialog.lineEditTime.text(), "250" + sep + "000m")
# Close the dialog via finished
dialog.finished.emit(0)
QApplication.instance().processEvents()
QTest.qWait(self.CLOSE_TIMEOUT)
def from_xml(cls, tag):
result = SimulatorSleepAction()
result.sleep_time = Formatter.str2val(tag.get("sleep_time", "1.0"), float, 1.0)
return result
def set_time(self):
self.dialog_ui.lineEditTime.setText(Formatter.science_time(self.num_samples / self.sample_rate, decimals=3,
append_seconds=False, remove_spaces=True))
def from_xml(self, tag: ET.Element, participants, decoders=None, message_types=None):
super().from_xml(tag, participants, decoders, message_types)
self.destination = Participant.find_matching(tag.get("destination_id", ""), participants)
self.repeat = Formatter.str2val(tag.get("repeat", "1"), int, 1)
def get_pause_str(self, sample_rate):
if sample_rate:
return ' [<b>Pause:</b> %s]' % (Formatter.science_time(self.pause / sample_rate))
else:
return ' [<b>Pause:</b> %d samples]' % (self.pause)
def mouseMoveEvent(self, event: QMouseEvent):
if isinstance(self.scene(), GridScene):
freq = self.scene().get_freq_for_pos(int(self.mapToScene(event.pos()).x()))
if freq is not None:
QToolTip.showText(self.mapToGlobal(event.pos()), "Tune to:" + Formatter.big_value_with_suffix(freq),
None, QRect(), 10000)
def set_duration(self):
dur = self.signal.num_samples / self.signal.sample_rate
self.ui.lDuration.setText(Formatter.science_time(dur))
