def test_external_with_interpreter(self):
code = get_path_for_data_file("code.py")
encoder = get_path_for_data_file("encode.py")
decoder = get_path_for_data_file("decode.py")
dir_with_spaces = os.path.join(tempfile.gettempdir(), "directory", "with extra space")
os.makedirs(dir_with_spaces, exist_ok=True)
coder_in_dir_with_spaces = os.path.join(dir_with_spaces, "code.py")
encoder_in_dir_with_spaces = os.path.join(dir_with_spaces, "encode.py")
decoder_in_dir_with_spaces = os.path.join(dir_with_spaces, "decode.py")
shutil.copy(code, coder_in_dir_with_spaces)
shutil.copy(encoder, encoder_in_dir_with_spaces)
shutil.copy(decoder, decoder_in_dir_with_spaces)
coder_in_dir_with_spaces = '{} "{}"'.format(sys.executable, coder_in_dir_with_spaces)
e = Encoding(["test external with spaces", constants.DECODING_EXTERNAL,
coder_in_dir_with_spaces + " d" + ";" + coder_in_dir_with_spaces + " e"])
data = array.array("B", [1, 0, 1, 0, 0, 1, 1])
encoded = e.encode(data)
self.assertEqual(encoded, array.array("B", [1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1]))
decoded = e.decode(encoded)
self.assertEqual(decoded, data)
def setUp(self):
self.field_types = FieldType.default_field_types()
self.preamble_field_type = self.__field_type_with_function(self.field_types, FieldType.Function.PREAMBLE)
self.sync_field_type = self.__field_type_with_function(self.field_types, FieldType.Function.SYNC)
self.length_field_type = self.__field_type_with_function(self.field_types, FieldType.Function.LENGTH)
self.sequence_number_field_type = self.__field_type_with_function(self.field_types,
FieldType.Function.SEQUENCE_NUMBER)
self.dst_address_field_type = self.__field_type_with_function(self.field_types, FieldType.Function.DST_ADDRESS)
self.src_address_field_type = self.__field_type_with_function(self.field_types, FieldType.Function.SRC_ADDRESS)
self.protocol = ProtocolAnalyzer(None)
with open(get_path_for_data_file("awre_consistent_addresses.txt")) as f:
for line in f:
self.protocol.messages.append(Message.from_plain_bits_str(line.replace("\n", "")))
self.protocol.messages[-1].message_type = self.protocol.default_message_type
# Assign participants
alice = Participant("Alice", "A")
bob = Participant("Bob", "B")
alice_indices = {1, 2, 5, 6, 9, 10, 13, 14, 17, 18, 20, 22, 23, 26, 27, 30, 31, 34, 35, 38, 39, 41}
for i, message in enumerate(self.protocol.messages):
message.participant = alice if i in alice_indices else bob
self.participants = [alice, bob]
self.zero_crc_protocol = ProtocolAnalyzer(None)
with open(get_path_for_data_file("awre_zeroed_crc.txt")) as f:
for line in f:
self.zero_crc_protocol.messages.append(Message.from_plain_bits_str(line.replace("\n", "")))
self.zero_crc_protocol.messages[-1].message_type = self.protocol.default_message_type
for i, message in enumerate(self.zero_crc_protocol.messages):
message.participant = alice if i in alice_indices else bob
def test_external(self):
encoder = get_path_for_data_file("encode.py")
decoder = get_path_for_data_file("decode.py")
e = Encoding(["test external", constants.DECODING_EXTERNAL, decoder+";"+encoder])
data = array.array("B", [1, 0, 1, 0, 0, 1, 1])
encoded = e.encode(data)
self.assertEqual(encoded, array.array("B", [1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1]))
decoded = e.decode(encoded)
self.assertEqual(decoded, data)
def setUp(self):
self.protocol = ProtocolAnalyzer(None)
with open(get_path_for_data_file("decoded_bits.txt")) as f:
for line in f:
self.protocol.messages.append(Message.from_plain_bits_str(line.replace("\n", "")))
self.protocol.messages[-1].message_type = self.protocol.default_message_type
# Assign participants
alice = Participant("Alice", "A")
bob = Participant("Bob", "B")
alice_indices = {1,2,5,6,9,10,13,14,17,18,20,22,23,26,27,30,31,34,35,38,39,41}
for i, message in enumerate(self.protocol.messages):
if i in alice_indices:
message.participant = alice
else:
message.participant = bob
self.assertEqual(self.protocol.num_messages, 42)
self.assertEqual(self.protocol.plain_hex_str[0][16:18], "2d")
self.decodings = []
self.decodings.append(Encoding(['Non Return To Zero (NRZ)']))
self.decodings.append(Encoding(['Non Return To Zero Inverted (NRZ-I)', 'Invert']))
self.decodings.append(Encoding(['Manchester I', 'Edge Trigger']))
self.decodings.append(Encoding(['Manchester II', 'Edge Trigger', 'Invert']))
self.decodings.append(Encoding(['Differential Manchester', 'Edge Trigger', 'Differential Encoding', ]))
self.decodings.append(Encoding(['DeWhitening Special', constants.DECODING_DATAWHITENING, '0x9a7d9a7d;0x21']))
self.decodings.append(Encoding(['DeWhitening', constants.DECODING_DATAWHITENING, '0x67686768;0x21']))
def test_auto_detect_esaver(self):
signal = Signal(get_path_for_data_file("esaver.complex"), "ESaver")
signal.modulation_type = 1
signal.qad_center = signal.estimate_qad_center()
self.assertTrue(0.24 < signal.qad_center < 0.5)
signal.bit_len = signal.estimate_bitlen()
self.assertTrue(80 <= signal.bit_len <= 120)
def test_auto_detect_fsk(self):
signal = Signal(get_path_for_data_file("fsk.complex"), "FSK")
signal.modulation_type = 1
signal.qad_center = signal.estimate_qad_center()
self.assertTrue(-0.1 <= signal.qad_center <= 0)
signal.bit_len = signal.estimate_bitlen()
self.assertTrue(90 <= signal.bit_len <= 110)
def test_auto_detect_elektromaten(self):
signal = Signal(get_path_for_data_file("elektromaten.complex"), "Elektromaten")
signal.modulation_type = 0
signal.qad_center = signal.estimate_qad_center()
self.assertTrue(0.0015 < signal.qad_center < 0.0140)
signal.bit_len = signal.estimate_bitlen()
self.assertTrue(270 <= signal.bit_len <= 330)
def test_qad_stays_the_same(self):
signal = Signal(get_path_for_data_file("esaver.complex"), "ESaver")
signal.modulation_type = 1
signal.qad_center = signal.estimate_qad_center()
qad_center = signal.qad_center
for i in range(10):
self.assertEqual(qad_center, signal.estimate_qad_center())
def test_auto_detect_ask(self):
signal = Signal(get_path_for_data_file("ask.complex"), "ASK")
signal.modulation_type = 0
signal.qad_center = signal.estimate_qad_center()
self.assertTrue(0 <= signal.qad_center <= 0.0036)
signal.bit_len = signal.estimate_bitlen()
self.assertTrue(270 <= signal.bit_len <= 330)
def test_format_finding_enocean(self):
enocean_protocol = ProtocolAnalyzer(None)
with open(get_path_for_data_file("enocean_bits.txt")) as f:
for line in f:
enocean_protocol.messages.append(Message.from_plain_bits_str(line.replace("\n", "")))
enocean_protocol.messages[-1].message_type = enocean_protocol.default_message_type
preamble_start = 3
preamble_end = 10
sof_start = 11
sof_end = 14
preamble_label = ProtocolLabel(name=self.preamble_field_type.caption, field_type=self.preamble_field_type,
start=preamble_start, end=preamble_end, color_index=0)
sync_label = ProtocolLabel(name=self.sync_field_type.caption, field_type=self.sync_field_type,
start=sof_start, end=sof_end, color_index=1)
ff = FormatFinder(enocean_protocol, self.participants, field_types=self.field_types)
ff.perform_iteration()
self.assertEqual(len(enocean_protocol.message_types), 1)
self.assertIn(preamble_label, enocean_protocol.default_message_type)
self.assertIn(sync_label, enocean_protocol.default_message_type)
self.assertTrue(
not any(lbl.name == self.length_field_type.caption for lbl in enocean_protocol.default_message_type))
self.assertTrue(not any("address" in lbl.name.lower() for lbl in enocean_protocol.default_message_type))
def setUp(self):
self.signal = Signal(get_path_for_data_file("esaver.complex"), "test")
self.signal.sample_rate = 2e6
self.dialog = SignalDetailsController(self.signal)
if self.SHOW:
self.dialog.show()
def test_fsk(self):
signal = Signal(get_path_for_data_file("fsk.complex"), "FSK-Test")
signal.modulation_type = 1
signal.bit_len = 100
signal.qad_center = 0
proto_analyzer = ProtocolAnalyzer(signal)
proto_analyzer.get_protocol_from_signal()
self.assertEqual(proto_analyzer.plain_bits_str[0],
"101010101010101010101010101010101100011000100110110001100010011011110100110111000001110110011000111011101111011110100100001001111001100110011100110100100011100111010011111100011")
def test_get_bit_sample_pos(self):
signal = Signal(get_path_for_data_file("ASK_mod.complex"), "Bit sample pos test")
signal.modulation_type = 0
signal.bit_len = 100
proto_analyzer = ProtocolAnalyzer(signal)
proto_analyzer.get_protocol_from_signal()
self.assertEqual(proto_analyzer.num_messages, 1)
for i, pos in enumerate(proto_analyzer.messages[0].bit_sample_pos):
self.assertLess(pos, signal.num_samples, msg = i)
def test_ask(self):
signal = Signal(get_path_for_data_file("ask.complex"), "ASK-Test")
signal.modulation_type = 0
signal.bit_len = 295
signal.qad_center = -0.1667
self.assertEqual(signal.num_samples, 13710)
proto_analyzer = ProtocolAnalyzer(signal)
proto_analyzer.get_protocol_from_signal()
self.assertTrue(proto_analyzer.plain_bits_str[0].startswith("1011001001011011011011011011011011001000000"))
def test_psk(self):
signal = Signal(get_path_for_data_file("psk_gen_noisy.complex"), "PSK-Test")
signal.modulation_type = 2
signal.bit_len = 300
signal.qad_center = 0.0281
signal.noise_threshold = 0
signal.tolerance = 10
proto_analyzer = ProtocolAnalyzer(signal)
proto_analyzer.get_protocol_from_signal()
self.assertEqual(proto_analyzer.plain_bits_str[0], "101100")
def test_carrier_auto_detect(self):
signal = Signal(get_path_for_data_file("wsp.complex"), "test")
signal.modulation_type = 0
signal.noise_threshold = 0.035
signal.qad_center = 0.0245
signal.bit_len = 25
pa = ProtocolAnalyzer(signal)
pa.get_protocol_from_signal()
start, num_samples = pa.get_samplepos_of_bitseq(0, 0, 0, 999999, include_pause=False)
print("-----------")
print(signal.estimate_frequency(start, end=start+num_samples, sample_rate=2e6))
def test_assign_decodings(self):
self.undecoded_protocol = ProtocolAnalyzer(None)
with open(get_path_for_data_file("undecoded.txt")) as f:
for line in f:
self.undecoded_protocol.messages.append(Message.from_plain_bits_str(line.replace("\n", "")))
self.undecoded_protocol.auto_assign_decodings(self.decodings)
for i, message in enumerate(self.undecoded_protocol.messages):
if message.plain_hex_str[8:16] == "9a7d9a7d":
self.assertEqual(message.decoder.name, "DeWhitening Special", msg=str(i))
elif message.plain_hex_str[8:16] == "67686768":
self.assertEqual(message.decoder.name, "DeWhitening", msg=str(i))
def test_get_rssi_of_message(self):
signal = Signal(get_path_for_data_file("two_participants.coco"), "RSSI-Test")
signal.modulation_type = 1
signal.bit_len = 100
signal.qad_center = -0.0507
proto_analyzer = ProtocolAnalyzer(signal)
proto_analyzer.get_protocol_from_signal()
self.assertEqual(proto_analyzer.num_messages, 18)
messages = proto_analyzer.messages
self.assertLess(messages[0].rssi, messages[1].rssi)
self.assertGreater(messages[1].rssi, messages[2].rssi)
self.assertLess(messages[2].rssi, messages[3].rssi)
self.assertLess(messages[-2].rssi, messages[-1].rssi)
def test_write(self):
signal = Signal(get_path_for_data_file("ask.complex"), "ASK-Test")
signal.modulation_type = 0
signal.bit_len = 295
signal.qad_center = -0.1667
self.assertEqual(signal.num_samples, 13710)
proto_analyzer = ProtocolAnalyzer(signal)
proto_analyzer.get_protocol_from_signal()
self.assertEqual(proto_analyzer.decoded_hex_str[0], "b25b6db6c80")
proto_analyzer.messages.append(copy.deepcopy(proto_analyzer.messages[0]))
proto_analyzer.messages.append(copy.deepcopy(proto_analyzer.messages[0]))
proto_analyzer.messages.append(copy.deepcopy(proto_analyzer.messages[0]))
pcap = PCAP()
pcap.write_packets(proto_analyzer.messages, os.path.join(tempfile.gettempdir(), "test.pcap"), 1e6)
def test_freq_detection(self):
s = Signal(get_path_for_data_file("steckdose_anlernen.complex"), "RWE")
s.noise_threshold = 0.06
s.qad_center = 0
s.bit_len = 100
pa = ProtocolAnalyzer(s)
pa.get_protocol_from_signal()
self.assertEqual(pa.messages[0].plain_bits_str,
"101010101010101010101010101010101001101001111101100110100111110111010010011000010110110101111"
"010111011011000011000101000010001001101100101111010110100110011100100110000101001110100001111"
"111101000111001110000101110100100111010110110100001101101101010100011011010001010110011100011"
"010100010101111110011010011001000000110010011010001000100100100111101110110010011111011100010"
"10110010100011111101110111000010111100111101001011101101011011010110101011100")
start, nsamples = pa.get_samplepos_of_bitseq(0, 0, 0, 1, False)
freq = s.estimate_frequency(start, start + nsamples, 1e6)
self.assertEqual(freq, 10000) # Freq for 1 is 10K
def test_fsk_freq_detection(self):
s = Signal(get_path_for_data_file("steckdose_anlernen.complex"), "RWE")
s.noise_threshold = 0.06
s.qad_center = 0
s.bit_len = 100
pa = ProtocolAnalyzer(s)
pa.get_protocol_from_signal()
self.assertEqual(pa.messages[0].plain_bits_str,
"101010101010101010101010101010101001101001111101100110100111110111010010011000010110110101111"
"010111011011000011000101000010001001101100101111010110100110011100100110000101001110100001111"
"111101000111001110000101110100100111010110110100001101101101010100011011010001010110011100011"
"010100010101111110011010011001000000110010011010001000100100100111101110110010011111011100010"
"10110010100011111101110111000010111100111101001011101101011011010110101011100")
freq = pa.estimate_frequency_for_one(1e6)
self.assertAlmostEqual(1, freq / 10000, places = 1) # Freq for 1 is 10K
freq = pa.estimate_frequency_for_zero(1e6)
self.assertAlmostEqual(3, freq / 10000, places = 1) # Freq for 0 is 30K
def setUp(self):
super().setUp()
QApplication.instance().processEvents()
QTest.qWait(self.WAIT_TIMEOUT_BEFORE_NEW)
self.form.add_protocol_file(get_path_for_data_file("protocol.proto"))
self.cframe = self.form.compare_frame_controller
self.cframe.add_protocol_label(9, 19, 0, 0, edit_label_name=False) # equals 10-20 in view
self.cframe.add_protocol_label(39, 54, 1, 0, edit_label_name=False) # equals 40-55 in view
self.assertEqual(len(self.cframe.proto_analyzer.protocol_labels), 2)
self.dialog = ProtocolLabelController(preselected_index=1,
message=self.cframe.proto_analyzer.messages[0],
viewtype=0, parent=self.cframe)
if self.SHOW:
self.dialog.show()
def get_path_for_filename(self, filename) -> str:
return get_path_for_data_file(filename)
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.coco"))
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.1,
5,
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_bit = 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.1)
# 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.1)
receive_process.join(20)
logger.info("PROCESS TIME: {0:.2f}ms".format(elapsed.value))
self.assertEqual(current_index.value, target_num_samples)
self.assertLess(elapsed.value, 200)
def setUp(self):
self.signal = Signal(get_path_for_data_file("esaver.complex"), "test")
self.signal.sample_rate = 2e6
self.dialog = SignalDetailsController(self.signal)
def setUp(self):
super().setUp()
settings.OVERWRITE_RECEIVE_BUFFER_SIZE = 600000
self.signal = Signal(get_path_for_data_file("enocean.complex"), "testsignal")
self.form.ui.tabWidget.setCurrentIndex(2)
def setUp(self):
super().setUp()
if os.path.isfile(get_path_for_data_file("URHProject.xml")):
os.remove(get_path_for_data_file("URHProject.xml"))
self.form.project_manager.set_project_folder(get_path_for_data_file(""), ask_for_new_project=False)
self.gframe = self.form.generator_tab_controller
def setUp(self):
self.old_sym_len = constants.SETTINGS.value('rel_symbol_length',
type=int)
constants.SETTINGS.setValue('rel_symbol_length',
0) # Disable Symbols for this Test
self.form = MainController()
self.form.add_signalfile(
get_path_for_data_file("steckdose_anlernen.complex"))
self.form.signal_tab_controller.signal_frames[
0].ui.spinBoxNoiseTreshold.setValue(0.06)
self.form.signal_tab_controller.signal_frames[
0].ui.spinBoxNoiseTreshold.editingFinished.emit()
self.form.signal_tab_controller.signal_frames[
0].ui.spinBoxCenterOffset.setValue(-0.0127)
self.form.signal_tab_controller.signal_frames[
0].ui.spinBoxCenterOffset.editingFinished.emit()
self.form.signal_tab_controller.signal_frames[
0].ui.spinBoxInfoLen.setValue(100)
self.form.signal_tab_controller.signal_frames[
0].ui.spinBoxInfoLen.editingFinished.emit()
self.sframe = self.form.signal_tab_controller.signal_frames[0]
self.cframe = self.form.compare_frame_controller
self.gframe = self.form.generator_tab_controller
# Dewhitening mit SyncByte 0x9a7d9a7d, Data Whitening Poly 0x21, Compute and apply CRC16 via X0r,
# Rest auf False anlegen und setzen
self.form.ui.tabWidget.setCurrentIndex(1)
self.cframe.ui.cbProtoView.setCurrentIndex(1) # Hex
decoding = Encoder([
"Data Whitening", constants.DECODING_DATAWHITENING,
"0x9a7d9a7d;0x21;0x8"
])
self.cframe.decodings.append(decoding)
self.cframe.ui.cbDecoding.addItem(decoding.name)
self.cframe.set_decoding(decoding)
# CRC Check
self.assertEqual(self.cframe.protocol_model.display_data[0][-4:],
"0000")
# Serial Part 1: Bits 207-226 (Dezimal: 91412) (20 Bits)
self.cframe.add_protocol_label(start=206,
end=225,
messagenr=0,
proto_view=0,
edit_label_name=False)
# Zeros: Bits 227-244 (18 Bits)
self.cframe.add_protocol_label(start=226,
end=243,
messagenr=0,
proto_view=0,
edit_label_name=False)
# Serial Part 2: Bit 245 - 264 (Dezimal: 1034678) (20 Bits)
self.cframe.add_protocol_label(start=244,
end=263,
messagenr=0,
proto_view=0,
edit_label_name=False)
self.form.ui.tabWidget.setCurrentIndex(2)
item = self.gframe.tree_model.rootItem.children[0].children[0]
index = self.gframe.tree_model.createIndex(0, 0, item)
rect = self.gframe.ui.treeProtocols.visualRect(index)
self.assertEqual(len(self.gframe.ui.treeProtocols.selectedIndexes()),
0)
QTest.mousePress(self.gframe.ui.treeProtocols.viewport(),
Qt.LeftButton,
pos=rect.center())
self.assertEqual(self.gframe.ui.treeProtocols.selectedIndexes()[0],
index)
mimedata = self.gframe.tree_model.mimeData(
self.gframe.ui.treeProtocols.selectedIndexes())
self.gframe.table_model.dropMimeData(
mimedata, 1, -1, -1, self.gframe.table_model.createIndex(0, 0))
self.assertEqual(self.gframe.table_model.row_count, 1)
self.assertEqual(len(self.gframe.table_model.protocol.protocol_labels),
3)
def setUp(self):
constants.SETTINGS.setValue("not_show_save_dialog", True)
self.form = MainController()
self.form.add_signalfile(get_path_for_data_file("esaver.complex"))
self.frame = self.form.signal_tab_controller.signal_frames[0]
def setUp(self):
super().setUp()
self.signal = Signal(get_path_for_data_file("esaver.complex"),
"testsignal")
self.form.ui.tabWidget.setCurrentIndex(2)
def add_signal_to_form(self, filename: str):
self.wait_before_new_file()
self.form.add_signalfile(get_path_for_data_file(filename))
def setUp(self):
self.form = MainController()
self.form.project_manager.set_project_folder(
get_path_for_data_file(""), ask_for_new_project=False)
self.cframe = self.form.compare_frame_controller
self.gframe = self.form.generator_tab_controller
def setUp(self):
self.signal = Signal(get_path_for_data_file("two_participants.complex16s"), "test")
def setUp(self):
super().setUp()
SettingsProxy.OVERWRITE_RECEIVE_BUFFER_SIZE = 10**6
self.signal = Signal(get_path_for_data_file("esaver.complex"),
"testsignal")
self.form.ui.tabWidget.setCurrentIndex(2)
def setUp(self):
super().setUp()
self.form.project_manager.set_project_folder(
get_path_for_data_file(""), ask_for_new_project=False)
self.gframe = self.form.generator_tab_controller
def setUp(self):
super().setUp()
SettingsProxy.OVERWRITE_RECEIVE_BUFFER_SIZE = 600000
self.signal = Signal(get_path_for_data_file("esaver.coco"), "testsignal")
self.form.ui.tabWidget.setCurrentIndex(2)
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.coco"))
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.1, 5, 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_bit = 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 test_external_program_simulator(self):
stc = self.form.simulator_tab_controller # type: SimulatorTabController
stc.ui.btnAddParticipant.click()
stc.ui.btnAddParticipant.click()
stc.project_manager.simulator_timeout_ms = 999999999
stc.simulator_scene.add_counter_action(None, 0)
action = next(item for item in stc.simulator_scene.items()
if isinstance(item, CounterActionItem))
action.model_item.start = 3
action.model_item.step = 2
counter_item_str = "item" + str(
action.model_item.index()) + ".counter_value"
stc.ui.gvSimulator.add_empty_message(42)
stc.ui.gvSimulator.add_empty_message(42)
stc.ui.cbViewType.setCurrentIndex(0)
stc.create_simulator_label(0, 10, 20)
stc.create_simulator_label(1, 10, 20)
messages = stc.simulator_config.get_all_messages()
messages[0].source = stc.project_manager.participants[0]
messages[0].destination = stc.project_manager.participants[1]
messages[0].destination.simulate = True
messages[1].source = stc.project_manager.participants[1]
messages[1].destination = stc.project_manager.participants[0]
stc.simulator_scene.add_trigger_command_action(None, 200)
stc.simulator_scene.add_sleep_action(None, 200)
lbl1 = messages[0].message_type[0] # type: SimulatorProtocolLabel
lbl2 = messages[1].message_type[0] # type: SimulatorProtocolLabel
ext_program = get_path_for_data_file(
"external_program_simulator.py") + " " + counter_item_str
if sys.platform == "win32":
ext_program = sys.executable + " " + ext_program
lbl1.value_type_index = 3
lbl1.external_program = ext_program
lbl2.value_type_index = 3
lbl2.external_program = ext_program
action = next(item for item in stc.simulator_scene.items()
if isinstance(item, SleepActionItem))
action.model_item.sleep_time = 0.000000001
stc.simulator_scene.clearSelection()
action = next(item for item in stc.simulator_scene.items()
if isinstance(item, TriggerCommandActionItem))
action.setSelected(True)
self.assertEqual(stc.ui.detail_view_widget.currentIndex(), 4)
file_name = os.path.join(tempfile.gettempdir(), "external_test")
if os.path.isfile(file_name):
os.remove(file_name)
self.assertFalse(os.path.isfile(file_name))
external_command = "cmd.exe /C copy NUL {}".format(
file_name) if os.name == "nt" else "touch {}".format(file_name)
stc.ui.lineEditTriggerCommand.setText(external_command)
self.assertEqual(action.model_item.command, external_command)
port = self.get_free_port()
self.alice = NetworkSDRInterfacePlugin(raw_mode=True)
self.alice.client_port = port
dialog = stc.get_simulator_dialog()
name = NetworkSDRInterfacePlugin.NETWORK_SDR_NAME
dialog.device_settings_rx_widget.ui.cbDevice.setCurrentText(name)
dialog.device_settings_tx_widget.ui.cbDevice.setCurrentText(name)
QTest.qWait(100)
simulator = dialog.simulator
simulator.sniffer.rcv_device.set_server_port(port)
port = self.get_free_port()
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
s.bind(("", port))
s.listen(1)
simulator.sender.device.set_client_port(port)
dialog.ui.btnStartStop.click()
QTest.qWait(250)
while not any("Waiting for message" in msg
for msg in dialog.simulator.log_messages):
logger.debug("Waiting for simulator to wait for message")
time.sleep(1)
conn, addr = s.accept()
modulator = dialog.project_manager.modulators[0] # type: Modulator
self.alice.send_raw_data(modulator.modulate("100" + "10101010" * 42),
1)
time.sleep(self.TIMEOUT)
self.alice.send_raw_data(
np.zeros(self.num_zeros_for_pause, dtype=np.complex64), 1)
while not any("Sending message" in msg
for msg in dialog.simulator.log_messages):
logger.debug("Waiting for simulator to send message")
time.sleep(1)
time.sleep(self.TIMEOUT)
bits = self.__demodulate(conn)
self.assertEqual(bits[0].rstrip("0"), "101010101")
while simulator.is_simulating:
logger.debug("Wait for simulator to finish")
time.sleep(1)
NetworkSDRInterfacePlugin.shutdown_socket(conn)
NetworkSDRInterfacePlugin.shutdown_socket(s)
self.assertTrue(os.path.isfile(file_name))
def setUp(self):
self.signal = Signal(get_path_for_data_file("two_participants.coco"), "test")
def test_load_proto(self):
QApplication.instance().processEvents()
QTest.qWait(self.WAIT_TIMEOUT_BEFORE_NEW)
self.form.add_files([get_path_for_data_file("protocol.proto")])
self.assertEqual(self.form.signal_tab_controller.signal_frames[0].ui.lSignalTyp.text(), "Protocol (*.proto)")
def test_analyze_button_fsk(self):
self.form.add_signalfile(get_path_for_data_file("fsk.complex"))
self.cfc.ui.btnAnalyze.click()
self.assertTrue(True)
def test_sniff(self):
# add a signal so we can use it
tests.utils_testing.short_wait()
self.form.add_signalfile(get_path_for_data_file("esaver.complex"))
logger.debug("Added signalfile")
app.processEvents()
# Move with encoding to generator
gframe = self.form.generator_tab_controller
gframe.ui.cbViewType.setCurrentIndex(0)
item = gframe.tree_model.rootItem.children[0].children[0]
index = gframe.tree_model.createIndex(0, 0, item)
rect = gframe.ui.treeProtocols.visualRect(index)
QTest.mousePress(gframe.ui.treeProtocols.viewport(),
Qt.LeftButton,
pos=rect.center())
self.assertEqual(gframe.ui.treeProtocols.selectedIndexes()[0], index)
mimedata = gframe.tree_model.mimeData(
gframe.ui.treeProtocols.selectedIndexes())
gframe.table_model.dropMimeData(mimedata, 1, -1, -1,
gframe.table_model.createIndex(0, 0))
self.assertEqual(gframe.table_model.rowCount(), 3)
tests.utils_testing.short_wait()
sniff_dialog = self.__get_sniff_dialog()
sniff_dialog.ui.cbDevice.setCurrentText(
NetworkSDRInterfacePlugin.NETWORK_SDR_NAME)
self.assertEqual(sniff_dialog.device.name,
NetworkSDRInterfacePlugin.NETWORK_SDR_NAME)
sniff_dialog.device.set_server_port(4444)
gframe.network_sdr_plugin.client_port = 4444
sniff_dialog.ui.btnStart.click()
app.processEvents()
gframe.ui.btnNetworkSDRSend.click()
app.processEvents()
QTest.qWait(self.SEND_RECV_TIMEOUT)
received_msgs = sniff_dialog.ui.txtEd_sniff_Preview.toPlainText(
).split("\n")
orig_msgs = gframe.table_model.protocol.plain_bits_str
self.assertEqual(len(received_msgs), len(orig_msgs))
for received, orig in zip(received_msgs, orig_msgs):
pad = 0 if len(orig) % 8 == 0 else 8 - len(orig) % 8
self.assertEqual(received, orig + "0" * pad)
sniff_dialog.ui.btnStop.click()
target_file = os.path.join(QDir.tempPath(), "sniff_file")
self.assertFalse(os.path.isfile(target_file))
sniff_dialog.ui.btnClear.click()
app.processEvents()
sniff_dialog.ui.lineEdit_sniff_OutputFile.setText(target_file)
sniff_dialog.ui.btnStart.click()
app.processEvents()
self.assertFalse(sniff_dialog.ui.btnAccept.isEnabled())
gframe.ui.btnNetworkSDRSend.click()
app.processEvents()
QTest.qWait(self.SEND_RECV_TIMEOUT)
with open(target_file, "r") as f:
for i, line in enumerate(f):
pad = 0 if len(
orig_msgs[i]) % 8 == 0 else 8 - len(orig_msgs[i]) % 8
self.assertEqual(line.strip(), orig_msgs[i] + "0" * pad)
os.remove(target_file)
def test_generation(self):
"""
Complex test including much functionality
1) Load a Signal
2) Set Decoding in Compareframe
3) Move with encoding to Generator
4) Generate datafile
5) Read datafile and compare with original signal
"""
# Load a Signal
self.form.add_signalfile(get_path_for_data_file("ask.complex"))
sframe = self.form.signal_tab_controller.signal_frames[0]
sframe.ui.cbModulationType.setCurrentIndex(0) # ASK
sframe.ui.spinBoxInfoLen.setValue(295)
sframe.ui.spinBoxCenterOffset.setValue(-0.1667)
sframe.refresh()
proto = "1011001001011011011011011011011011001000000"
self.assertTrue(sframe.ui.txtEdProto.toPlainText().startswith(proto))
# Set Decoding
self.form.ui.tabWidget.setCurrentIndex(1)
cfc = self.form.compare_frame_controller
cfc.ui.cbDecoding.setCurrentIndex(1) # NRZ-I
proto_inv = cfc.proto_analyzer.decoded_proto_bits_str[0]
self.assertTrue(self.__is_inv_proto(proto, proto_inv))
# Move with encoding to generator
gframe = self.form.generator_tab_controller
gframe.ui.cbViewType.setCurrentIndex(0)
item = gframe.tree_model.rootItem.children[0].children[0]
index = gframe.tree_model.createIndex(0, 0, item)
rect = gframe.ui.treeProtocols.visualRect(index)
QTest.mousePress(gframe.ui.treeProtocols.viewport(),
Qt.LeftButton,
pos=rect.center())
self.assertEqual(gframe.ui.treeProtocols.selectedIndexes()[0], index)
mimedata = gframe.tree_model.mimeData(
gframe.ui.treeProtocols.selectedIndexes())
gframe.table_model.dropMimeData(mimedata, 1, -1, -1,
gframe.table_model.createIndex(0, 0))
self.assertEqual(proto_inv, gframe.table_model.display_data[0])
self.assertNotEqual(proto, gframe.table_model.display_data[0])
# Generate Datafile
modulator = gframe.modulators[0]
modulator.modulation_type = 0
modulator.samples_per_bit = 295
modulated_data = gframe.modulate_data()
filename = os.path.join(QDir.tempPath(), "generator_test.complex")
modulated_data.tofile(filename)
# Reload datafile and see if bits match
self.form.add_signalfile(filename)
sframe = self.form.signal_tab_controller.signal_frames[1]
self.assertEqual(sframe.ui.lineEditSignalName.text(), "generator_test")
sframe.ui.cbSignalView.setCurrentIndex(1) # ASK
sframe.ui.spinBoxInfoLen.setValue(295)
sframe.ui.spinBoxInfoLen.editingFinished.emit()
sframe.ui.spinBoxCenterOffset.setValue(0.1)
sframe.ui.spinBoxCenterOffset.editingFinished.emit()
sframe.refresh()
gen_proto = sframe.ui.txtEdProto.toPlainText()
gen_proto = gen_proto[:gen_proto.index(" ")]
self.assertTrue(proto.startswith(gen_proto))
def setUp(self):
super().setUp()
self.signal = Signal(get_path_for_data_file("esaver.complex"), "testsignal")
self.form.ui.tabWidget.setCurrentIndex(2)
def test_external_program_simulator(self):
stc = self.form.simulator_tab_controller # type: SimulatorTabController
stc.ui.btnAddParticipant.click()
stc.ui.btnAddParticipant.click()
stc.project_manager.simulator_timeout_ms = 999999999
stc.simulator_scene.add_counter_action(None, 0)
action = next(item for item in stc.simulator_scene.items() if isinstance(item, CounterActionItem))
action.model_item.start = 3
action.model_item.step = 2
counter_item_str = "item" + str(action.model_item.index()) + ".counter_value"
stc.ui.gvSimulator.add_empty_message(42)
stc.ui.gvSimulator.add_empty_message(42)
stc.ui.cbViewType.setCurrentIndex(0)
stc.create_simulator_label(0, 10, 20)
stc.create_simulator_label(1, 10, 20)
messages = stc.simulator_config.get_all_messages()
messages[0].source = stc.project_manager.participants[0]
messages[0].destination = stc.project_manager.participants[1]
messages[0].destination.simulate = True
messages[1].source = stc.project_manager.participants[1]
messages[1].destination = stc.project_manager.participants[0]
stc.simulator_scene.add_trigger_command_action(None, 200)
stc.simulator_scene.add_sleep_action(None, 200)
lbl1 = messages[0].message_type[0] # type: SimulatorProtocolLabel
lbl2 = messages[1].message_type[0] # type: SimulatorProtocolLabel
ext_program = get_path_for_data_file("external_program_simulator.py") + " " + counter_item_str
if sys.platform == "win32":
ext_program = sys.executable + " " + ext_program
lbl1.value_type_index = 3
lbl1.external_program = ext_program
lbl2.value_type_index = 3
lbl2.external_program = ext_program
action = next(item for item in stc.simulator_scene.items() if isinstance(item, SleepActionItem))
action.model_item.sleep_time = 0.000000001
stc.simulator_scene.clearSelection()
action = next(item for item in stc.simulator_scene.items() if isinstance(item, TriggerCommandActionItem))
action.setSelected(True)
self.assertEqual(stc.ui.detail_view_widget.currentIndex(), 4)
file_name = os.path.join(tempfile.gettempdir(), "external_test")
if os.path.isfile(file_name):
os.remove(file_name)
self.assertFalse(os.path.isfile(file_name))
external_command = "cmd.exe /C copy NUL {}".format(file_name) if os.name == "nt" else "touch {}".format(file_name)
stc.ui.lineEditTriggerCommand.setText(external_command)
self.assertEqual(action.model_item.command, external_command)
port = self.get_free_port()
self.alice = NetworkSDRInterfacePlugin(raw_mode=True)
self.alice.client_port = port
dialog = stc.get_simulator_dialog()
name = NetworkSDRInterfacePlugin.NETWORK_SDR_NAME
dialog.device_settings_rx_widget.ui.cbDevice.setCurrentText(name)
dialog.device_settings_tx_widget.ui.cbDevice.setCurrentText(name)
QTest.qWait(100)
simulator = dialog.simulator
simulator.sniffer.rcv_device.set_server_port(port)
port = self.get_free_port()
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
s.bind(("", port))
s.listen(1)
simulator.sender.device.set_client_port(port)
dialog.ui.btnStartStop.click()
QTest.qWait(250)
while not any("Waiting for message" in msg for msg in dialog.simulator.log_messages):
logger.debug("Waiting for simulator to wait for message")
time.sleep(1)
conn, addr = s.accept()
modulator = dialog.project_manager.modulators[0] # type: Modulator
self.alice.send_raw_data(modulator.modulate("100" + "10101010" * 42), 1)
time.sleep(self.TIMEOUT)
self.alice.send_raw_data(np.zeros(self.num_zeros_for_pause, dtype=np.complex64), 1)
while not any("Sending message" in msg for msg in dialog.simulator.log_messages):
logger.debug("Waiting for simulator to send message")
time.sleep(1)
time.sleep(self.TIMEOUT)
bits = self.__demodulate(conn)
self.assertEqual(bits[0].rstrip("0"), "101010101")
while simulator.is_simulating:
logger.debug("Wait for simulator to finish")
time.sleep(1)
NetworkSDRInterfacePlugin.shutdown_socket(conn)
NetworkSDRInterfacePlugin.shutdown_socket(s)
self.assertTrue(os.path.isfile(file_name))
def setUp(self):
super().setUp()
if os.path.isfile(get_path_for_data_file("URHProject.xml")):
os.remove(get_path_for_data_file("URHProject.xml"))
self.form.project_manager.set_project_folder(get_path_for_data_file(""), ask_for_new_project=False)
self.gframe = self.form.generator_tab_controller
def test_load_proto(self):
self.form.add_files([get_path_for_data_file("protocol.proto")])
self.assertEqual(self.form.signal_tab_controller.signal_frames[1].ui.lSignalTyp.text(), "Protocol (*.proto)")
def add_signal_to_form(self, filename: str):
self.wait_before_new_file()
self.form.add_signalfile(get_path_for_data_file(filename))
def setUp(self):
constants.SETTINGS.setValue("NetworkSDRInterface", True)
QTest.qWait(50)
logger.debug("init form")
self.form = MainController()
logger.debug("initalized form")
app.processEvents()
QTest.qWait(75)
logger.debug("Adding signalfile")
self.form.add_signalfile(get_path_for_data_file("esaver.complex"))
logger.debug("Added signalfile")
app.processEvents()
self.signal = self.form.signal_tab_controller.signal_frames[0].signal
self.gframe = self.form.generator_tab_controller
self.form.ui.tabWidget.setCurrentIndex(2)
app.processEvents()
QTest.qWait(100)
project_manager = self.form.project_manager
logger.debug("Creating Receive Dialog")
self.receive_dialog = ReceiveDialogController(project_manager,
testing_mode=True,
parent=self.form)
app.processEvents()
QTest.qWait(50)
logger.debug("Creating Send Dialog")
self.send_dialog = SendDialogController(
project_manager,
modulated_data=self.signal.data,
testing_mode=True,
parent=self.form)
self.send_dialog.graphics_view.show_full_scene(reinitialize=True)
app.processEvents()
QTest.qWait(50)
logger.debug("Creating Spectrum Dialog")
self.spectrum_dialog = SpectrumDialogController(project_manager,
testing_mode=True,
parent=self.form)
app.processEvents()
QTest.qWait(50)
logger.debug("Creating Sniff Dialog")
self.sniff_dialog = ProtocolSniffDialogController(
project_manager,
self.signal.noise_threshold,
self.signal.qad_center,
self.signal.bit_len,
self.signal.tolerance,
self.signal.modulation_type,
testing_mode=True,
parent=self.form)
app.processEvents()
QTest.qWait(50)
logger.debug("Created Dialogs")
self.dialogs = [
self.receive_dialog, self.send_dialog, self.spectrum_dialog,
self.sniff_dialog
]
def add_signal_to_form(self, filename: str):
self.form.add_signalfile(get_path_for_data_file(filename))
