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 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 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 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 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 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_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 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")
