def assign_messagetypes(self, messages, clusters): """ Assign message types based on the clusters. Following rules: 1) Messages from different clusters will get different message types 2) Messages from same clusters will get same message type 3) The new message type will copy over the existing labels 4) No new message type will be set for messages, that already have a custom message type assigned For messages with clustername "default" no new message type will be created :param messages: Messages, that messagetype needs to be clustered :param clusters: clusters for the messages :type messages: list[Message] :type clusters: dict[str, set[int]] :return: """ for clustername, clustercontent in clusters.items(): if clustername == "default": # Do not force the default message type continue for msg_i in clustercontent: msg = messages[msg_i] if msg.message_type == self.messagetypes[0]: # Message has default message type # Copy the existing labels and create a new message type # if it was not already done try: msg_type = next(mtype for mtype in self.messagetypes if mtype.name == clustername) except StopIteration: msg_type = MessageType(name=clustername, iterable=msg.message_type) msg_type.assigned_by_logic_analyzer = True self.messagetypes.append(msg_type) msg.message_type = msg_type
def test_crc_widget_in_protocol_label_dialog(self): mt = MessageType("test") mt.append(ChecksumLabel("test_crc", 8, 16, 0, FieldType("test_crc", FieldType.Function.CHECKSUM))) self.dialog = ProtocolLabelController(0, Message([0] * 100, 0, mt), 0) self.assertEqual(self.dialog.ui.tabWidgetAdvancedSettings.count(), 1) self.assertEqual(self.dialog.ui.tabWidgetAdvancedSettings.tabText(0), "test_crc")
def prepare_modulation_dialog( self) -> (ModulatorDialogController, Message): preselected_index = self.ui.cBoxModulations.currentIndex() min_row, max_row, start, end = self.ui.tableMessages.selection_range() if min_row > -1: try: selected_message = self.table_model.protocol.messages[min_row] preselected_index = selected_message.modulator_indx except IndexError: selected_message = Message([True, False, True, False], 0, [], MessageType("empty")) else: selected_message = Message([True, False, True, False], 0, [], MessageType("empty")) if len(self.table_model.protocol.messages) > 0: selected_message.bit_len = self.table_model.protocol.messages[ 0].bit_len for m in self.modulators: m.default_sample_rate = self.project_manager.device_conf[ "sample_rate"] modulator_dialog = ModulatorDialogController(self.modulators, parent=self.parent()) modulator_dialog.ui.treeViewSignals.setModel(self.tree_model) modulator_dialog.ui.treeViewSignals.expandAll() modulator_dialog.ui.comboBoxCustomModulations.setCurrentIndex( preselected_index) modulator_dialog.finished.connect(self.refresh_modulators) modulator_dialog.finished.connect(self.refresh_pause_list) return modulator_dialog, selected_message
def prepare_modulation_dialog(self) -> (ModulatorDialog, Message): preselected_index = self.ui.cBoxModulations.currentIndex() min_row, max_row, start, end = self.ui.tableMessages.selection_range() if min_row > -1: try: selected_message = self.table_model.protocol.messages[min_row] preselected_index = selected_message.modulator_index except IndexError: selected_message = Message( [1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0], 0, [], MessageType("empty")) else: selected_message = Message( [1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0], 0, [], MessageType("empty")) if len(self.table_model.protocol.messages) > 0: selected_message.samples_per_symbol = self.table_model.protocol.messages[ 0].samples_per_symbol for m in self.modulators: m.default_sample_rate = self.project_manager.device_conf[ "sample_rate"] modulator_dialog = ModulatorDialog(self.modulators, tree_model=self.tree_model, parent=self.parent()) modulator_dialog.ui.comboBoxCustomModulations.setCurrentIndex( preselected_index) modulator_dialog.finished.connect(self.refresh_modulators) modulator_dialog.finished.connect(self.refresh_pause_list) return modulator_dialog, selected_message
def test_crc_widget_in_protocol_label_dialog(self): mt = MessageType("test") mt.append( ChecksumLabel("test_crc", 8, 16, 0, FieldType("test_crc", FieldType.Function.CHECKSUM))) self.dialog = ProtocolLabelController(0, Message([0] * 100, 0, mt), 0) self.assertEqual(self.dialog.ui.tabWidgetAdvancedSettings.count(), 1) self.assertEqual(self.dialog.ui.tabWidgetAdvancedSettings.tabText(0), "test_crc")
def test_message_break_plugin(self): bp = MessageBreakPlugin() n = 1 action = bp.get_action(self.cframe.ui.tblViewProtocol, self.cframe.protocol_undo_stack, (n, n, 4, 4), self.cframe.proto_analyzer, 0) self.assertEqual(self.cframe.protocol_model.row_count, 3) original_msg = self.cframe.proto_analyzer.messages[n] original_msg.message_type = MessageType( "Test", [ProtocolLabel("Test Label", 2, 42, 0)]) msg_type = original_msg.message_type old_msg_len = len(original_msg) action.trigger() # Now we have two messages: One before and including selection and one behind selection msg_1 = self.cframe.proto_analyzer.messages[n] msg_2 = self.cframe.proto_analyzer.messages[n + 1] self.assertEqual(len(msg_1), 4) self.assertEqual(len(msg_2), old_msg_len - 4) self.assertEqual(msg_type, msg_1.message_type) self.assertEqual(msg_type, msg_2.message_type) self.assertEqual(self.cframe.protocol_model.row_count, 4) self.cframe.protocol_undo_stack.undo() self.assertEqual(self.cframe.protocol_model.row_count, 3)
def test_default_crcs(self): crc_label = ChecksumLabel( "crc_label", 25, 120, 0, FieldType("crc", FieldType.Function.CHECKSUM)) crc_widget_controller = ChecksumWidgetController( crc_label, Message([0] * 150, 0, MessageType("test")), 0) default_crc_polynomials = GenericCRC.DEFAULT_POLYNOMIALS special_crcs = ChecksumWidgetController.SPECIAL_CRCS self.assertEqual( len(default_crc_polynomials) + len(special_crcs), crc_widget_controller.ui.comboBoxCRCFunction.count()) for i, default_polynomial_name in enumerate(default_crc_polynomials): self.assertEqual( default_polynomial_name, crc_widget_controller.ui.comboBoxCRCFunction.itemText(i)) for i, special_crc in enumerate(special_crcs): self.assertEqual( special_crc, crc_widget_controller.ui.comboBoxCRCFunction.itemText( i + len(default_crc_polynomials))) crc_widget_controller.ui.comboBoxCRCFunction.setCurrentIndex(1) self.assertNotEqual( crc_widget_controller.ui.comboBoxCRCFunction.currentText(), "8_standard") crc_widget_controller.ui.comboBoxCRCFunction.setCurrentText( "8_standard") self.assertEqual( crc_widget_controller.ui.comboBoxCRCFunction.currentText(), "8_standard") self.assertEqual(crc_widget_controller.ui.lineEditCRCPolynomial.text(), "d5")
def test_configure_crc_parameters(self): crc_label = ChecksumLabel( "crc_label", 25, 120, 0, FieldType("crc", FieldType.Function.CHECKSUM)) crc_widget_controller = ChecksumWidgetController( crc_label, Message([0] * 150, 0, MessageType("test")), 0) crc = GenericCRC( polynomial=list(GenericCRC.DEFAULT_POLYNOMIALS.keys())[0]) self.assertEqual(crc_widget_controller.ui.lineEditCRCPolynomial.text(), crc.polynomial_as_hex_str) self.assertEqual(crc_widget_controller.ui.lineEditStartValue.text(), util.bit2hex(crc.start_value)) self.assertEqual(crc_widget_controller.ui.lineEditFinalXOR.text(), util.bit2hex(crc.final_xor)) crc_widget_controller.ui.comboBoxCRCFunction.setCurrentIndex(2) crc.polynomial = crc.choose_polynomial(2) self.assertEqual(crc_widget_controller.ui.lineEditCRCPolynomial.text(), crc.polynomial_as_hex_str) crc_widget_controller.ui.lineEditCRCPolynomial.setText("abcde") crc_widget_controller.ui.lineEditCRCPolynomial.editingFinished.emit() self.assertEqual(crc_label.checksum.polynomial, array.array("B", [1]) + util.hex2bit("abcde")) crc_widget_controller.ui.lineEditStartValue.setText("12345") crc_widget_controller.ui.lineEditStartValue.editingFinished.emit() self.assertEqual(util.bit2hex(crc_label.checksum.start_value), "12345") crc_widget_controller.ui.lineEditFinalXOR.setText("cccaa") crc_widget_controller.ui.lineEditFinalXOR.editingFinished.emit() self.assertEqual(util.bit2hex(crc_label.checksum.final_xor), "cccaa")
def from_xml(self, tag: ET.Element, participants, decoders=None, message_types=None): part_id = tag.get("participant_id", None) message_type_id = tag.get("message_type_id", None) self.modulator_indx = int(tag.get("modulator_index", self.modulator_indx)) self.pause = int(tag.get("pause", self.pause)) decoding_index = tag.get("decoding_index", None) if decoding_index: try: self.decoder = decoders[int(decoding_index)] except IndexError: pass if part_id: for participant in participants: if participant.id_match(part_id): self.participant = participant break if self.participant is None: logger.warning("No participant matched the id {0} from xml".format(part_id)) if message_type_id and message_types: for message_type in message_types: if message_type.id == message_type_id: self.message_type = message_type break message_type_tag = tag.find("message_type") if message_type_tag: self.message_type = MessageType.from_xml(message_type_tag)
def test_message_type_assign_by_value(self): start = 8 end = 15 hex_value = "9a7d9a7d" msg_type = MessageType("autotest") msg_type.ruleset = Ruleset(Mode.all_apply, [Rule(start, end, "=", hex_value, 1)]) msg_type.assigned_by_ruleset = True self.protocol.message_types.append(msg_type) self.protocol.update_auto_message_types() matching_indices = [0, 2, 3, 21, 23, 24] for i, message in enumerate(self.protocol.messages): if i in matching_indices: self.assertEqual(message.message_type, msg_type, msg=str(i)) else: self.assertEqual(message.message_type, self.protocol.default_message_type, msg=str(i))
def test_find_unlabeled_range(self): lbl11 = ProtocolLabel(name="Label 1.1", start=2, end=10, color_index=0) lbl12 = ProtocolLabel(name="Label 1.2", start=15, end=20, color_index=0) lbl13 = ProtocolLabel(name="Label 1.3", start=40, end=60, color_index=0) mt1 = MessageType(name="MT1", iterable=[lbl11, lbl12, lbl13]) self.assertEqual([(0, 2), (11, 15), (21, 40), (61, None)], mt1.unlabeled_ranges) self.assertEqual([(0, 2), (11, 15), (21, 40), (61, None)], mt1.unlabeled_ranges_with_other_mt(mt1)) lbl21 = ProtocolLabel(name="Label 2.1", start=1, end=11, color_index=0) lbl22 = ProtocolLabel(name="Label 2.2", start=14, end=18, color_index=0) lbl23 = ProtocolLabel(name="Label 2.3", start=50, end=70, color_index=0) mt2 = MessageType(name="MT2", iterable=[lbl21, lbl22, lbl23]) self.assertEqual(mt1.unlabeled_ranges_with_other_mt(mt2), mt2.unlabeled_ranges_with_other_mt(mt1)) self.assertEqual(mt1.unlabeled_ranges_with_other_mt(mt2), [(0, 1), (11, 14), (21, 40), (71, None)])
def from_xml_tag(self, root: ET.Element, read_bits=False, participants=None, decodings=None): if not root: return None if root.find("modulators") and hasattr(self, "modulators"): self.modulators[:] = [] for mod_tag in root.find("modulators").findall("modulator"): self.modulators.append(Modulator.from_xml(mod_tag)) decoders = self.read_decoders_from_xml_tag( root) if decodings is None else decodings if participants is None: participants = self.read_participants_from_xml_tag(root) if read_bits: self.messages[:] = [] try: message_types = [] for message_type_tag in root.find("message_types").findall( "message_type"): message_types.append(MessageType.from_xml(message_type_tag)) except AttributeError: message_types = [] for message_type in message_types: if message_type not in self.message_types: self.message_types.append(message_type) try: message_tags = root.find("messages").findall("message") for i, message_tag in enumerate(message_tags): if read_bits: message = Message.from_plain_bits_str( bits=message_tag.get("bits")) message.from_xml(tag=message_tag, participants=participants, decoders=decoders, message_types=self.message_types) self.messages.append(message) else: try: self.messages[i].from_xml( tag=message_tag, participants=participants, decoders=decoders, message_types=self.message_types) except IndexError: pass # Part of signal was copied in last session but signal was not saved except AttributeError: pass
def add_new_message_type(self, labels): names = set(message_type.name for message_type in self.message_types) name = "Message type #" i = 0 while True: i += 1 if name + str(i) not in names: self.message_types.append( MessageType(name=name + str(i), iterable=[copy.deepcopy(lbl) for lbl in labels])) break
def read_message_types(self): if self.project_file is None: return None tree = ET.parse(self.project_file) root = tree.getroot() try: return [MessageType.from_xml(msg_type_tag) for msg_type_tag in root.find("protocol").find("message_types").findall("message_type")] except AttributeError: return []
def read_message_types(self): if self.project_file is None: return None tree = ET.parse(self.project_file) root = tree.getroot() result = [] for msg_type_tag in root.find("protocol").find("message_types").findall("message_type"): result.append(MessageType.from_xml(msg_type_tag)) return result
def create_message(self, destination, plain_bits, pause, message_type, decoder, source): if destination is None: destination = self.simulator_config.broadcast_part sim_message = SimulatorMessage(destination=destination, plain_bits=plain_bits, pause=pause, message_type=MessageType(message_type.name), decoder=decoder, source=source) for lbl in message_type: sim_label = SimulatorProtocolLabel(copy.deepcopy(lbl)) sim_message.insert_child(-1, sim_label) return sim_message
def add_message_type(self, message: SimulatorMessage): names = set(message_type.name for message_type in self.proto_analyzer.message_types) name = "Message type #" i = next(i for i in itertools.count(start=1) if name + str(i) not in names) msg_type_name, ok = QInputDialog.getText(self, self.tr("Enter message type name"), self.tr("Name:"), text=name + str(i)) if ok: msg_type = MessageType(name=msg_type_name) for lbl in message.message_type: msg_type.add_protocol_label(start=lbl.start, end=lbl.end - 1, name=lbl.name, color_ind=lbl.color_index, type=lbl.field_type) self.proto_analyzer.message_types.append(msg_type) self.compare_frame_controller.fill_message_type_combobox() self.compare_frame_controller.active_message_type = self.compare_frame_controller.active_message_type message.message_type.name = msg_type_name self.simulator_config.items_updated.emit([message])
def __init__(self, signal: Signal): self.messages = [] # type: list[Message] self.signal = signal self.filename = self.signal.filename if self.signal is not None else "" self.__name = "Blank" # Fallback if Signal has no Name self.show = Qt.Checked # Show in Compare Frame? self.qt_signals = ProtocolAnalyzerSignals() self.decoder = Encoding(["Non Return To Zero (NRZ)"]) # For Default Encoding of Protocol self.message_types = [MessageType("default")]
def from_xml_tag(self, root: ET.Element, read_bits=False, participants=None, decodings=None): if not root: return None decoders = Encoding.read_decoders_from_xml_tag( root) if decodings is None else decodings if participants is None: participants = Participant.read_participants_from_xml_tag(root) if read_bits: self.messages[:] = [] try: message_types = [] for message_type_tag in root.find("message_types").findall( "message_type"): message_types.append(MessageType.from_xml(message_type_tag)) except AttributeError: message_types = [] for message_type in message_types: if message_type not in self.message_types: self.message_types.append(message_type) try: message_tags = root.find("messages").findall("message") for i, message_tag in enumerate(message_tags): if read_bits: self.messages.append( Message.new_from_xml(tag=message_tag, participants=participants, decoders=decoders, message_types=self.message_types)) else: try: self.messages[i].from_xml( tag=message_tag, participants=participants, decoders=decoders, message_types=self.message_types) except IndexError: pass # Part of signal was copied in last session but signal was not saved except AttributeError: pass
def test_homematic(self): proto_file = get_path_for_data_file("homematic.proto.xml") protocol = ProtocolAnalyzer(signal=None, filename=proto_file) protocol.message_types = [] protocol.from_xml_file(filename=proto_file, read_bits=True) # prevent interfering with preassinged labels protocol.message_types = [MessageType("Default")] participants = sorted({msg.participant for msg in protocol.messages}) self.clear_message_types(protocol.messages) ff = FormatFinder(protocol.messages, participants=participants) ff.known_participant_addresses.clear() ff.perform_iteration() self.assertGreater(len(ff.message_types), 0) for i, message_type in enumerate(ff.message_types): preamble = message_type.get_first_label_with_type(FieldType.Function.PREAMBLE) self.assertEqual(preamble.start, 0) self.assertEqual(preamble.length, 32) sync = message_type.get_first_label_with_type(FieldType.Function.SYNC) self.assertEqual(sync.start, 32) self.assertEqual(sync.length, 32) length = message_type.get_first_label_with_type(FieldType.Function.LENGTH) self.assertEqual(length.start, 64) self.assertEqual(length.length, 8) seq = message_type.get_first_label_with_type(FieldType.Function.SEQUENCE_NUMBER) self.assertEqual(seq.start, 72) self.assertEqual(seq.length, 8) src = message_type.get_first_label_with_type(FieldType.Function.SRC_ADDRESS) self.assertEqual(src.start, 96) self.assertEqual(src.length, 24) dst = message_type.get_first_label_with_type(FieldType.Function.DST_ADDRESS) self.assertEqual(dst.start, 120) self.assertEqual(dst.length, 24) checksum = message_type.get_first_label_with_type(FieldType.Function.CHECKSUM) self.assertEqual(checksum.length, 16) self.assertIn("CC1101", checksum.checksum.caption) for msg_index in ff.existing_message_types[message_type]: msg_len = len(protocol.messages[msg_index]) self.assertEqual(checksum.start, msg_len-16) self.assertEqual(checksum.end, msg_len)
def from_plain_bits_str(bits, symbols: dict): plain_bits = [] for b in bits: if b == "0": plain_bits.append(False) elif b == "1": plain_bits.append(True) else: try: plain_bits.append(symbols[b]) except KeyError: print("[Warning] Did not find symbol name", file=sys.stderr) plain_bits.append(Symbol(b, 0, 0, 1)) return Message(plain_bits=plain_bits, pause=0, message_type=MessageType("none"))
def add_empty_message(self, num_bits): if hasattr(self.sender(), "data") and self.sender().data(): message_type = self.sender().data() else: message_type = MessageType("Default") ref_item = self.context_menu_item if isinstance(ref_item, RuleConditionItem): position = QAbstractItemView.OnItem else: position = QAbstractItemView.BelowItem message = self.scene().add_message(plain_bits=[0] * num_bits, pause=0, message_type=message_type, ref_item=ref_item, position=position) self.jump_to_item(message)
def generate_rwe(cls, num_messages: int, save_protocol=True): proto_file = get_path_for_data_file("rwe.proto.xml") protocol = ProtocolAnalyzer(signal=None, filename=proto_file) protocol.from_xml_file(filename=proto_file, read_bits=True) messages = protocol.messages result = ProtocolAnalyzer(None) message_type = MessageType("empty") for i in range(num_messages): msg = messages[i % len(messages)] # type: Message msg.message_type = message_type result.messages.append(msg) if save_protocol: cls.save_protocol("rwe", result) return result
def __init__(self, signal: Signal or None, filename=None): self.messages = [] # type: list[Message] self.signal = signal if filename is None: self.filename = self.signal.filename if self.signal is not None else "" else: assert signal is None self.filename = filename self.__name = urh_util.get_name_from_filename(filename) # Fallback if Signal has no Name self.show = Qt.Checked # Show in Compare Frame? self.qt_signals = ProtocolAnalyzerSignals() self.decoder = Encoding(["Non Return To Zero (NRZ)"]) # For Default Encoding of Protocol self.message_types = [MessageType("Default")]
def from_xml_tag(self, root: ET.Element, read_bits=False, participants=None, decodings=None): if not root: return None if root.find("modulators") and hasattr(self, "modulators"): self.modulators[:] = [] for mod_tag in root.find("modulators").findall("modulator"): self.modulators.append(Modulator.from_xml(mod_tag)) decoders = self.read_decoders_from_xml_tag(root) if decodings is None else decodings if participants is None: participants = self.read_participants_from_xml_tag(root) if read_bits: self.messages[:] = [] try: message_types = [] for message_type_tag in root.find("message_types").findall("message_type"): message_types.append(MessageType.from_xml(message_type_tag)) except AttributeError: message_types = [] for message_type in message_types: if message_type not in self.message_types: self.message_types.append(message_type) try: message_tags = root.find("messages").findall("message") for i, message_tag in enumerate(message_tags): if read_bits: message = Message.from_plain_bits_str(bits=message_tag.get("bits")) message.from_xml(tag=message_tag, participants=participants, decoders=decoders, message_types=self.message_types) self.messages.append(message) else: try: self.messages[i].from_xml(tag=message_tag, participants=participants, decoders=decoders, message_types=self.message_types) except IndexError: pass # Part of signal was copied in last session but signal was not saved except AttributeError: pass
def generate_enocean(cls, num_messages: int, save_protocol=True): filename = get_path_for_data_file("enocean_bits.txt") enocean_bits = [] with open(filename, "r") as f: for line in map(str.strip, f): enocean_bits.append(line) protocol = ProtocolAnalyzer(None) message_type = MessageType("empty") for i in range(num_messages): msg = Message.from_plain_bits_str(enocean_bits[i % len(enocean_bits)]) msg.message_type = message_type protocol.messages.append(msg) if save_protocol: cls.save_protocol("enocean", protocol) return protocol
def test_enocean_checksum(self): checksum_label = ChecksumLabel( "checksum_label", 50, 100, 0, FieldType("crc", FieldType.Function.CHECKSUM)) crc_widget_controller = ChecksumWidgetController( checksum_label, Message([0] * 100, 0, MessageType("test")), 0) crc_widget_controller.ui.comboBoxCategory.setCurrentIndex(1) self.assertEqual( crc_widget_controller.ui.stackedWidget.currentWidget(), crc_widget_controller.ui.page_wsp) self.assertTrue( crc_widget_controller.ui.radioButtonWSPAuto.isChecked()) crc_widget_controller.ui.radioButtonWSPChecksum8.click() self.assertEqual(checksum_label.checksum.mode, WSPChecksum.ChecksumMode.checksum8)
def on_add_message_action_triggered(self): num_bits, ok = QInputDialog.getInt( self, self.tr("How many bits shall the new message have?"), self.tr("Number of bits:"), 42, 1) if ok: message_type = MessageType("default") if not self.sender().data( ) else self.sender().data() ref_item = self.context_menu_item if isinstance(ref_item, RuleConditionItem): position = QAbstractItemView.OnItem else: position = QAbstractItemView.BelowItem message = self.scene().add_message(plain_bits=[0] * num_bits, pause=1000000, message_type=message_type, ref_item=ref_item, position=position) self.jump_to_item(message)
def add_range_to_message_type(common_range: CommonRange, message_type: MessageType): field_type = FieldType.from_caption(common_range.field_type) label = message_type.add_protocol_label(name=common_range.field_type, start=common_range.bit_start, end=common_range.bit_end, auto_created=True, type=field_type) label.display_endianness = common_range.byte_order if field_type.function == FieldType.Function.CHECKSUM: assert isinstance(label, ChecksumLabel) assert isinstance(common_range, ChecksumRange) label.data_ranges = [(common_range.data_range_bit_start, common_range.data_range_bit_end)] if isinstance(common_range.crc, WSPChecksum): label.category = ChecksumLabel.Category.wsp else: label.checksum = copy.copy(common_range.crc)
def from_xml_tag(self, root: ET.Element, read_bits=False, participants=None, decodings=None): if not root: return None decoders = Encoding.read_decoders_from_xml_tag(root) if decodings is None else decodings if participants is None: participants = Participant.read_participants_from_xml_tag(root) if read_bits: self.messages[:] = [] try: message_types = [] for message_type_tag in root.find("message_types").findall("message_type"): message_types.append(MessageType.from_xml(message_type_tag)) except AttributeError: message_types = [] for message_type in message_types: if message_type not in self.message_types: self.message_types.append(message_type) try: message_tags = root.find("messages").findall("message") for i, message_tag in enumerate(message_tags): if read_bits: self.messages.append(Message.new_from_xml(tag=message_tag, participants=participants, decoders=decoders, message_types=self.message_types)) else: try: self.messages[i].from_xml(tag=message_tag, participants=participants, decoders=decoders, message_types=self.message_types) except IndexError: pass # Part of signal was copied in last session but signal was not saved except AttributeError: pass
def test_configure_crc_ranges(self): checksum_label = ChecksumLabel( "checksum_label", 50, 100, 0, FieldType("crc", FieldType.Function.CHECKSUM)) crc_widget_controller = ChecksumWidgetController( checksum_label, Message([0] * 100, 0, MessageType("test")), 0) model = crc_widget_controller.data_range_table_model self.assertEqual(model.data(model.index(0, 0)), 1) self.assertEqual(model.data(model.index(0, 1)), 50) self.assertEqual(model.rowCount(), 1) crc_widget_controller.ui.btnAddRange.click() self.assertEqual(model.rowCount(), 2) crc_widget_controller.ui.btnAddRange.click() self.assertEqual(model.rowCount(), 3) crc_widget_controller.ui.btnRemoveRange.click() self.assertEqual(model.rowCount(), 2) crc_widget_controller.ui.btnRemoveRange.click() self.assertEqual(model.rowCount(), 1) crc_widget_controller.ui.btnRemoveRange.click() self.assertEqual(model.rowCount(), 1)
def test_performance(self): self.form = MainController() self.cfc = self.form.compare_frame_controller self.stc = self.form.simulator_tab_controller self.gtc = self.form.generator_tab_controller self.form.add_signalfile(get_path_for_data_file("esaver.complex16s")) self.sframe = self.form.signal_tab_controller.signal_frames[0] self.sim_frame = self.form.simulator_tab_controller self.form.ui.tabWidget.setCurrentIndex(3) self.cfc.proto_analyzer.auto_assign_labels() self.network_sdr_plugin_sender = NetworkSDRInterfacePlugin(raw_mode=True) part_a = Participant("Device A", shortname="A", color_index=0) part_b = Participant("Device B", shortname="B", color_index=1) part_b.simulate = True self.form.project_manager.participants.append(part_a) self.form.project_manager.participants.append(part_b) self.form.project_manager.project_updated.emit() sniffer = ProtocolSniffer(100, 0.01, 0.01, 0.1, 5, "FSK", 1, NetworkSDRInterfacePlugin.NETWORK_SDR_NAME, BackendHandler(), network_raw_mode=True) sender = EndlessSender(BackendHandler(), NetworkSDRInterfacePlugin.NETWORK_SDR_NAME) simulator = Simulator(self.stc.simulator_config, self.gtc.modulators, self.stc.sim_expression_parser, self.form.project_manager, sniffer=sniffer, sender=sender) pause = 100 msg_a = SimulatorMessage(part_b, [1, 0] * 16 + [1, 1, 0, 0] * 8 + [0, 0, 1, 1] * 8 + [1, 0, 1, 1, 1, 0, 0, 1, 1, 1] * 4, pause=pause, message_type=MessageType("empty_message_type"), source=part_a) msg_b = SimulatorMessage(part_a, [1, 0] * 16 + [1, 1, 0, 0] * 8 + [1, 1, 0, 0] * 8 + [1, 0, 1, 1, 1, 0, 0, 1, 1, 1] * 4, pause=pause, message_type=MessageType("empty_message_type"), source=part_b) self.stc.simulator_config.add_items([msg_a, msg_b], 0, None) self.stc.simulator_config.update_active_participants() port = self.get_free_port() sniffer = simulator.sniffer sniffer.rcv_device.set_server_port(port) self.network_sdr_plugin_sender.client_port = port sender = simulator.sender port = self.get_free_port() sender.device.set_client_port(port) sender.device._VirtualDevice__dev.name = "simulator_sender" current_index = Value("L") elapsed = Value("f") target_num_samples = 13600 + pause receive_process = Process(target=receive, args=(port, current_index, target_num_samples, elapsed)) receive_process.daemon = True receive_process.start() # Ensure receiver is running time.sleep(2) # spy = QSignalSpy(self.network_sdr_plugin_receiver.rcv_index_changed) simulator.start() modulator = Modulator("test_modulator") modulator.samples_per_symbol = 100 modulator.carrier_freq_hz = 55e3 # yappi.start() self.network_sdr_plugin_sender.send_raw_data(modulator.modulate(msg_a.encoded_bits), 1) time.sleep(0.5) # send some zeros to simulate the end of a message self.network_sdr_plugin_sender.send_raw_data(np.zeros(self.num_zeros_for_pause, dtype=np.complex64), 1) time.sleep(0.5) receive_process.join(15) logger.info("PROCESS TIME: {0:.2f}ms".format(elapsed.value)) # self.assertEqual(current_index.value, target_num_samples) self.assertLess(elapsed.value, 200) # timeout = spy.wait(2000) # yappi.get_func_stats().print_all() # yappi.get_thread_stats().print_all()
def push_data(self, data: np.ndarray): self.ringbuffer.push(data) if __name__ == '__main__': from urh.dev.BackendHandler import BackendHandler from urh.signalprocessing.Message import Message from urh.signalprocessing.MessageType import MessageType from urh.signalprocessing.Modulator import Modulator from urh.util.Logger import logger import time endless_sender = EndlessSender(BackendHandler(), "HackRF") msg = Message([1, 0] * 16 + [1, 1, 0, 0] * 8 + [0, 0, 1, 1] * 8 + [1, 0, 1, 1, 1, 0, 0, 1, 1, 1] * 4, 0, MessageType("empty_message_type")) modulator = Modulator("test_modulator") modulator.samples_per_bit = 1000 modulator.carrier_freq_hz = 55e3 logger.debug("Starting endless sender") endless_sender.start() time.sleep(1) logger.debug("Pushing data") endless_sender.push_data(modulator.modulate(msg.encoded_bits)) logger.debug("Pushed data") time.sleep(5) logger.debug("Stopping endless sender") endless_sender.stop() time.sleep(1) logger.debug("bye")