def test_performance(self):
t = time.time()
modulator = Modulator("Perf")
modulator.modulation_type = 1
modulator.modulate([True] * 1000, pause=10000000)
elapsed = time.time() - t
self.assertLess(elapsed, 0.5)
def test_plot(self):
modulator = Modulator("gfsk")
modulator.modulation_type_str = "GFSK"
modulator.samples_per_bit = 100
modulator.sample_rate = 1e6
modulator.param_for_one = 20e3
modulator.param_for_zero = 10e3
modulator.carrier_freq_hz = 15e3
modulator.carrier_phase_deg = 90
modulated_samples = modulator.modulate([True, False, True, False, False], 77)
data = copy.deepcopy(modulated_samples)
modulated_samples = modulator.modulate([False, True, True, True, True, False, True], 100, start=len(data))
data = np.concatenate((data, modulated_samples))
plt.subplot(2, 1, 1)
axes = plt.gca()
axes.set_ylim([-2,2])
plt.plot(data.real)
plt.title("Modulated Wave")
plt.subplot(2, 1, 2)
qad = signal_functions.afp_demod(np.ascontiguousarray(data), 0, 1)
plt.plot(qad)
plt.title("Quad Demod")
plt.show()
def test_performance(self):
t = time.time()
modulator = Modulator("Perf")
modulator.modulation_type = 1
modulator.modulate([True] * 1000, pause=10000000)
elapsed = time.time() - t
self.assertLess(elapsed, 0.5)
def test_plot(self):
modulator = Modulator("gfsk")
modulator.modulation_type_str = "GFSK"
modulator.samples_per_bit = 100
modulator.sample_rate = 1e6
modulator.param_for_one = 20e3
modulator.param_for_zero = 10e3
modulator.carrier_freq_hz = 15e3
modulator.carrier_phase_deg = 90
modulator.modulate([True, False, True, False, False], 77)
data = copy.deepcopy(modulator.modulated_samples)
modulator.modulate([False, True, True, True, True, False, True],
100,
start=len(data))
data = np.concatenate((data, modulator.modulated_samples))
plt.subplot(2, 1, 1)
axes = plt.gca()
axes.set_ylim([-2, 2])
plt.plot(data.real)
plt.title("Modulated Wave")
plt.subplot(2, 1, 2)
qad = signalFunctions.afp_demod(np.ascontiguousarray(data), 0, 1)
plt.plot(qad)
plt.title("Quad Demod")
plt.show()
def test_channels(self):
sample_rate = 10**6
channel1_freq = 40 * 10**3
channel2_freq = 240 * 10**3
channel1_data = array.array("B", [1, 0, 1, 0, 1, 0, 0, 1])
channel2_data = array.array("B", [1, 1, 0, 0, 1, 1, 0, 1])
filter_bw = 0.1
filter_freq1_high = 1.5 * channel1_freq
filter_freq1_low = 0.5 * channel1_freq
filter_freq2_high = 1.5 * channel2_freq
filter_freq2_low = 0.5 * channel2_freq
modulator1, modulator2 = Modulator("test"), Modulator("test2")
modulator1.carrier_freq_hz = channel1_freq
modulator2.carrier_freq_hz = channel2_freq
modulator1.sample_rate = modulator2.sample_rate = sample_rate
modulator1.modulate(channel1_data)
modulator2.modulate(channel2_data)
data1, data2 = modulator1.modulated_samples, modulator2.modulated_samples
mixed_signal = data1 + data2
plt.subplot("221")
plt.title("Signal")
plt.plot(mixed_signal)
spectrogram = Spectrogram(mixed_signal)
plt.subplot("222")
plt.title("Spectrogram")
plt.imshow(np.transpose(spectrogram.data), aspect="auto", cmap="magma")
plt.ylim(0, spectrogram.freq_bins)
chann1_filtered = Filter.apply_bandpass_filter(mixed_signal,
filter_freq1_low,
filter_freq1_high,
sample_rate, filter_bw)
plt.subplot("223")
plt.title("Channel 1 Filtered ({})".format("".join(
map(str, channel1_data))))
plt.plot(chann1_filtered)
chann2_filtered = Filter.apply_bandpass_filter(mixed_signal,
filter_freq2_low,
filter_freq2_high,
sample_rate, filter_bw)
plt.subplot("224")
plt.title("Channel 2 Filtered ({})".format("".join(
map(str, channel2_data))))
plt.plot(chann2_filtered)
plt.show()
def test_protocol_sniffer(self):
samples_per_symbol = 100
center = 0.0942
noise = 0.1
tolerance = 2
modulation_type = "FSK"
sample_rate = 1e6
device_name = NetworkSDRInterfacePlugin.NETWORK_SDR_NAME
sniffer = ProtocolSniffer(samples_per_symbol=samples_per_symbol, center=center, center_spacing=0.1,
noise=noise, tolerance=tolerance,
modulation_type=modulation_type, bits_per_symbol=1,
device=device_name, backend_handler=BackendHandler(),
network_raw_mode=True)
port = self.get_free_port()
sniffer.rcv_device.set_server_port(port)
self.network_sdr_plugin_sender = NetworkSDRInterfacePlugin(raw_mode=True)
self.network_sdr_plugin_sender.client_port = port
sniffer.sniff()
QTest.qWait(10)
data = ["101010", "000111", "1111000"]
pause = 10 * samples_per_symbol
modulator = Modulator("test")
modulator.samples_per_symbol = samples_per_symbol
modulator.sample_rate = sample_rate
modulator.modulation_type = modulation_type
modulator.parameters[1] = 20e3
modulator.parameters[0] = 10e3
packages = []
for d in data:
packages.append(modulator.modulate(list(map(int, d)), pause))
# verify modulation was correct
pa = ProtocolAnalyzer(None)
signal = Signal("", "", sample_rate=sample_rate)
signal.iq_array = IQArray.concatenate(packages)
signal.modulation_type = modulation_type
signal.samples_per_symbol = samples_per_symbol
signal.tolerance = tolerance
signal.noise_threshold = noise
signal.center = center
pa.signal = signal
pa.get_protocol_from_signal()
self.assertEqual(pa.plain_bits_str, data)
# send data
send_data = IQArray.concatenate(packages)
self.network_sdr_plugin_sender.send_raw_data(send_data, 1)
time.sleep(1)
# Send enough pauses to end sniffing
self.network_sdr_plugin_sender.send_raw_data(IQArray(None, np.float32, 10 * 2 * samples_per_symbol), 1)
time.sleep(1)
sniffer.stop()
self.assertEqual(sniffer.plain_bits_str, data)
def generate_signal(messages: list, modulator: Modulator, snr_db: int, add_noise=True):
result = []
message_powers = []
if isinstance(messages, Message):
messages = [messages]
for msg in messages:
modulated = modulator.modulate(msg.encoded_bits, msg.pause)
if add_noise:
message_powers.append(np.mean(np.abs(modulated[:len(modulated) - msg.pause])))
result.append(modulated)
result = np.concatenate(result)
if not add_noise:
return result
noise = np.random.normal(loc=0, scale=1, size=2 * len(result)).astype(np.float32).view(np.complex64)
# https://stackoverflow.com/questions/23690766/proper-way-to-add-noise-to-signal
snr_ratio = np.power(10, snr_db / 10)
signal_power = np.mean(message_powers)
noise_power = signal_power / snr_ratio
noise = 1 / np.sqrt(2) * noise_power * noise
return result + noise
def generate_signal(messages: list,
modulator: Modulator,
snr_db: int,
add_noise=True):
result = []
message_powers = []
if isinstance(messages, Message):
messages = [messages]
for msg in messages:
modulated = modulator.modulate(msg.encoded_bits, msg.pause)
if add_noise:
message_powers.append(
np.mean(np.abs(modulated[:len(modulated) - msg.pause])))
result.append(modulated)
result = np.concatenate(result)
if not add_noise:
return result
noise = np.random.normal(loc=0, scale=1, size=2 * len(result)).astype(
np.float32).view(np.complex64)
# https://stackoverflow.com/questions/23690766/proper-way-to-add-noise-to-signal
snr_ratio = np.power(10, snr_db / 10)
signal_power = np.mean(message_powers)
noise_power = signal_power / snr_ratio
noise = 1 / np.sqrt(2) * noise_power * noise
return result + noise
def test_segmentation_ask_50(self):
modulator = Modulator("ask50")
modulator.modulation_type = "ASK"
modulator.parameters[0] = 50
modulator.parameters[1] = 100
modulator.samples_per_symbol = 100
msg1 = modulator.modulate("1010101111", pause=10000)
msg2 = modulator.modulate("1010101110010101", pause=20000)
msg3 = modulator.modulate("1010101010101111", pause=30000)
data = IQArray.concatenate((msg1, msg2, msg3))
segments = segment_messages_from_magnitudes(data.magnitudes,
noise_threshold=0)
self.assertEqual(len(segments), 3)
self.assertEqual(segments, [(0, 999), (10999, 12599), (32599, 34199)])
def test_protocol_sniffer(self):
bit_len = 100
center = 0.0942
noise = 0.1
tolerance = 2
modulation_type = 1
sample_rate = 1e6
device_name = NetworkSDRInterfacePlugin.NETWORK_SDR_NAME
sniffer = ProtocolSniffer(bit_len=bit_len, center=center, noise=noise, tolerance=tolerance,
modulation_type=modulation_type, device=device_name, backend_handler=BackendHandler(),
network_raw_mode=True)
port = self.get_free_port()
sniffer.rcv_device.set_server_port(port)
self.network_sdr_plugin_sender = NetworkSDRInterfacePlugin(raw_mode=True)
self.network_sdr_plugin_sender.client_port = port
sniffer.sniff()
QTest.qWait(10)
data = ["101010", "000111", "1111000"]
pause = 10 * bit_len
modulator = Modulator("test")
modulator.samples_per_bit = bit_len
modulator.sample_rate = sample_rate
modulator.modulation_type = modulation_type
modulator.param_for_one = 20e3
modulator.param_for_zero = 10e3
packages = []
for d in data:
packages.append(modulator.modulate(list(map(int, d)), pause))
# verify modulation was correct
pa = ProtocolAnalyzer(None)
signal = Signal("", "", sample_rate=sample_rate)
signal._fulldata = np.concatenate(packages)
signal.modulation_type = modulation_type
signal.bit_len = bit_len
signal.tolerance = tolerance
signal.noise_threshold = noise
signal.qad_center = center
pa.signal = signal
pa.get_protocol_from_signal()
self.assertEqual(pa.plain_bits_str, data)
# send data
send_data = np.concatenate(packages)
self.network_sdr_plugin_sender.send_raw_data(send_data, 1)
time.sleep(1)
# Send enough pauses to end sniffing
self.network_sdr_plugin_sender.send_raw_data(np.zeros(10 * bit_len, dtype=np.complex64), 1)
time.sleep(1)
sniffer.stop()
self.assertEqual(sniffer.plain_bits_str, data)
def test_psk_detection(self):
modulator = Modulator("")
modulator.modulation_type_str = "PSK"
modulator.param_for_zero = 0
modulator.param_for_one = 180
data = modulator.modulate("10101010111000")
mod = AutoInterpretation.detect_modulation(data)
self.assertEqual(mod, "PSK")
def test_gfsk(self):
target_file = os.path.join(tempfile.gettempdir(), "test.complex")
modulator = Modulator("gfsk")
modulator.modulation_type_str = "FSK"
modulator.samples_per_bit = 100
modulator.sample_rate = 1e6
modulator.param_for_one = 20e3
modulator.param_for_zero = -10e3
data1 = modulator.modulate([True, False, False, True, False], 9437)
data2 = modulator.modulate([True, False, True], 9845) #, start=len(s))
data3 = modulator.modulate([True, False, True, False], 8457) #, start=len(s))
s = np.concatenate((data1, data2, data3))
s.tofile(target_file)
pa = ProtocolAnalyzer(Signal(target_file, "test", modulation="FSK"))
pa.get_protocol_from_signal()
def test_psk_detection(self):
modulator = Modulator("")
modulator.modulation_type_str = "PSK"
modulator.param_for_zero = 0
modulator.param_for_one = 180
data = modulator.modulate("10101010111000")
mod = AutoInterpretation.detect_modulation(data)
self.assertEqual(mod, "PSK")
def test_psk_detection(self):
modulator = Modulator("")
modulator.modulation_type = "PSK"
modulator.parameters[0] = 0
modulator.parameters[1] = 180
data = modulator.modulate("10101010111000")
mod = AutoInterpretation.detect_modulation(data)
self.assertEqual(mod, "PSK")
def test_segmentation_ask_50(self):
modulator = Modulator("ask50")
modulator.modulation_type_str = "ASK"
modulator.param_for_zero = 50
modulator.param_for_one = 100
modulator.samples_per_bit = 100
msg1 = modulator.modulate("1010101111", pause=10000)
msg2 = modulator.modulate("1010101110010101", pause=20000)
msg3 = modulator.modulate("1010101010101111", pause=30000)
data = np.concatenate((msg1, msg2, msg3))
segments = segment_messages_from_magnitudes(np.abs(data), noise_threshold=0)
print(segments)
self.assertEqual(len(segments), 3)
self.assertEqual(segments, [(0, 999), (10999, 12599), (32599, 34199)])
print(merge_message_segments_for_ook(segments))
def test_fsk_performance():
bit_data = "10" * 100 + "0000011111" + "001101011" * 100 + "111111100000" * 100
modulator = Modulator("Perf")
modulator.modulation_type_str = "FSK"
t = time.time()
result = modulator.modulate(bit_data, pause=10000000)
elapsed = time.time() - t
result.tofile("/tmp/fsk.complex")
print("FSK {}ms".format(elapsed * 1000))
def test_fsk_performance():
bit_data = "10" * 100 + "0000011111" + "001101011" * 100 + "111111100000" * 100
modulator = Modulator("Perf")
modulator.modulation_type_str = "FSK"
t = time.time()
result = modulator.modulate(bit_data, pause=10000000)
elapsed = time.time() - t
result.tofile("/tmp/fsk.complex")
print("FSK {}ms".format(elapsed * 1000))
def test_gfsk(self):
target_file = os.path.join(tempfile.gettempdir(), "test.complex")
modulator = Modulator("gfsk")
modulator.modulation_type_str = "FSK"
modulator.samples_per_symbol = 100
modulator.sample_rate = 1e6
modulator.param_for_one = 20e3
modulator.param_for_zero = -10e3
data1 = modulator.modulate([True, False, False, True, False], 9437)
data2 = modulator.modulate([True, False, True], 9845) #, start=len(s))
data3 = modulator.modulate([True, False, True, False],
8457) #, start=len(s))
s = np.concatenate((data1, data2, data3))
s.tofile(target_file)
pa = ProtocolAnalyzer(Signal(target_file, "test", modulation="FSK"))
pa.get_protocol_from_signal()
def test_ask_fsk_psk_modulation(self):
modulations = ["ASK", "FSK", "PSK"]
for i, modulation in enumerate(modulations):
modulator = Modulator(modulation)
tmp_dir = QDir.tempPath()
filename = "{0}_mod.complex".format(modulation)
filename = os.path.join(tmp_dir, filename)
modulator.modulation_type = i
modulator.samples_per_bit = self.samples_per_bit
if modulation == "ASK":
modulator.param_for_zero = 0
modulator.param_for_one = 100
elif modulation == "FSK":
modulator.param_for_zero = 1000
modulator.param_for_one = 2500
elif modulation == "PSK":
modulator.param_for_zero = 0
modulator.param_for_one = 180
modulator.modulate(self.modulation_data, self.pause)
modulator.modulated_samples.tofile(filename)
signal = Signal(filename, modulation)
signal.modulation_type = i
signal.bit_len = self.samples_per_bit
if modulation == "ASK":
signal.qad_center = 0.5
elif modulation == "FSK":
signal.qad_center = 0.0097
elif modulation == "PSK":
signal.qad_center = 0
self.assertEqual(signal.num_samples,
self.total_samples,
msg=modulation)
pa = ProtocolAnalyzer(signal)
pa.get_protocol_from_signal()
self.assertEqual(1, len(pa.messages), msg=modulation)
self.assertEqual(self.modulation_data,
pa.messages[0].plain_bits,
msg=modulation)
def test_ask_fsk_psk_modulation(self):
modulations = ["ASK", "FSK", "PSK"]
for modulation in modulations:
modulator = Modulator(modulation)
tmp_dir = QDir.tempPath()
filename = "{0}_mod.complex".format(modulation)
filename = os.path.join(tmp_dir, filename)
modulator.modulation_type = modulation
modulator.samples_per_symbol = self.samples_per_symbol
if modulation == "ASK":
modulator.parameters[0] = 0
modulator.parameters[1] = 100
elif modulation == "FSK":
modulator.parameters[0] = 1000
modulator.parameters[1] = 2500
elif modulation == "PSK":
modulator.parameters[0] = -90
modulator.parameters[1] = 90
modulator.modulate(self.modulation_data,
self.pause).tofile(filename)
signal = Signal(filename, modulation)
signal.modulation_type = modulation
signal.samples_per_symbol = self.samples_per_symbol
if modulation == "ASK":
signal.center = 0.5
elif modulation == "FSK":
signal.center = 0.0097
elif modulation == "PSK":
signal.center = 0
self.assertEqual(signal.num_samples,
self.total_samples,
msg=modulation)
pa = ProtocolAnalyzer(signal)
pa.get_protocol_from_signal()
self.assertEqual(1, len(pa.messages), msg=modulation)
self.assertEqual(self.modulation_data,
pa.messages[0].plain_bits,
msg=modulation)
def test_segmentation_ask_50(self):
modulator = Modulator("ask50")
modulator.modulation_type_str = "ASK"
modulator.param_for_zero = 50
modulator.param_for_one = 100
modulator.samples_per_bit = 100
msg1 = modulator.modulate("1010101111", pause=10000)
msg2 = modulator.modulate("1010101110010101", pause=20000)
msg3 = modulator.modulate("1010101010101111", pause=30000)
data = np.concatenate((msg1, msg2, msg3))
segments = segment_messages_from_magnitudes(np.abs(data),
noise_threshold=0)
print(segments)
self.assertEqual(len(segments), 3)
self.assertEqual(segments, [(0, 999), (10999, 12599), (32599, 34199)])
print(merge_message_segments_for_ook(segments))
def test_channels(self):
sample_rate = 10 ** 6
channel1_freq = 40 * 10 ** 3
channel2_freq = 240 * 10 ** 3
channel1_data = array.array("B", [1, 0, 1, 0, 1, 0, 0, 1])
channel2_data = array.array("B", [1, 1, 0, 0, 1, 1, 0, 1])
channel3_data = array.array("B", [1, 0, 0, 1, 0, 1, 1, 1])
filter_bw = 0.1
filter_freq1_high = 1.5 * channel1_freq
filter_freq1_low = 0.5 * channel1_freq
filter_freq2_high = 1.5*channel2_freq
filter_freq2_low = 0.5 * channel2_freq
modulator1, modulator2, modulator3 = Modulator("test"), Modulator("test2"), Modulator("test3")
modulator1.carrier_freq_hz = channel1_freq
modulator2.carrier_freq_hz = channel2_freq
modulator3.carrier_freq_hz = -channel2_freq
modulator1.sample_rate = modulator2.sample_rate = modulator3.sample_rate = sample_rate
data1 = modulator1.modulate(channel1_data)
data2 = modulator2.modulate(channel2_data)
data3 = modulator3.modulate(channel3_data)
mixed_signal = data1 + data2 + data3
mixed_signal.tofile("/tmp/three_channels.complex")
plt.subplot("221")
plt.title("Signal")
plt.plot(mixed_signal)
spectrogram = Spectrogram(mixed_signal)
plt.subplot("222")
plt.title("Spectrogram")
plt.imshow(np.transpose(spectrogram.data), aspect="auto", cmap="magma")
plt.ylim(0, spectrogram.freq_bins)
chann1_filtered = Filter.apply_bandpass_filter(mixed_signal, filter_freq1_low / sample_rate, filter_freq1_high / sample_rate, filter_bw)
plt.subplot("223")
plt.title("Channel 1 Filtered ({})".format("".join(map(str, channel1_data))))
plt.plot(chann1_filtered)
chann2_filtered = Filter.apply_bandpass_filter(mixed_signal, filter_freq2_low / sample_rate, filter_freq2_high / sample_rate, filter_bw)
plt.subplot("224")
plt.title("Channel 2 Filtered ({})".format("".join(map(str, channel2_data))))
plt.plot(chann2_filtered)
plt.show()
def test_ask_fsk_psk_modulation(self):
modulations = ["ASK", "FSK", "PSK"]
for i, modulation in enumerate(modulations):
modulator = Modulator(modulation)
tmp_dir = QDir.tempPath()
filename = "{0}_mod.complex".format(modulation)
filename = os.path.join(tmp_dir, filename)
modulator.modulation_type = i
modulator.samples_per_bit = self.samples_per_bit
if modulation == "ASK":
modulator.param_for_zero = 0
modulator.param_for_one = 100
elif modulation == "FSK":
modulator.param_for_zero = 1000
modulator.param_for_one = 2500
elif modulation == "PSK":
modulator.param_for_zero = 0
modulator.param_for_one = 180
modulator.modulate(self.modulation_data, self.pause)
modulator.modulated_samples.tofile(filename)
signal = Signal(filename, modulation)
signal.modulation_type = i
signal.bit_len = self.samples_per_bit
if modulation == "ASK":
signal.qad_center = 0.5
elif modulation == "FSK":
signal.qad_center = 0.0097
elif modulation == "PSK":
signal.qad_center = 0
self.assertEqual(signal.num_samples, self.total_samples, msg=modulation)
pa = ProtocolAnalyzer(signal)
pa.get_protocol_from_signal()
self.assertEqual(1, len(pa.messages), msg=modulation)
self.assertEqual(self.modulation_data, pa.messages[0].plain_bits, msg=modulation)
def test_gfsk(self):
modulator = Modulator("gfsk")
modulator.modulation_type_str = "FSK"
modulator.samples_per_bit = 100
modulator.sample_rate = 1e6
modulator.param_for_one = 20e3
modulator.param_for_zero = -10e3
modulator.modulate([True, False, False, True, False], 9437)
s = modulator.modulated_samples
modulator.modulate([True, False, True], 9845) #, start=len(s))
s = np.concatenate((s, modulator.modulated_samples))
modulator.modulate([True, False, True, False], 8457) #, start=len(s))
s = np.concatenate((s, modulator.modulated_samples))
s.tofile("/tmp/test.complex")
pa = ProtocolAnalyzer(Signal("/tmp/test.complex", "test", modulation="FSK"))
pa.get_protocol_from_signal()
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()
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")
def test_performance(self):
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.001,
5,
1,
NetworkSDRInterfacePlugin.NETWORK_SDR_NAME,
BackendHandler(),
network_raw_mode=True,
real_time=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)
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,
100000,
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,
100000,
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 = 113600
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(1)
# 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
modulator.modulate(msg_a.encoded_bits)
# yappi.start()
self.network_sdr_plugin_sender.send_raw_data(
modulator.modulated_samples, 1)
QTest.qWait(100)
receive_process.join(10)
print("PROCESS TIME: {0:.2f}ms".format(elapsed.value))
self.assertEqual(current_index.value, target_num_samples)
self.assertLess(elapsed.value, 200)
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")
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()
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
modulator.modulate(msg.encoded_bits)
modulator.modulated_samples.tofile("/tmp/test.complex")
logger.debug("Starting endless sender")
endless_sender.start()
time.sleep(1)
logger.debug("Pushing data")
endless_sender.push_data(modulator.modulated_samples)
logger.debug("Pushed data")
time.sleep(5)
logger.debug("Stopping endless sender")
endless_sender.stop()
time.sleep(1)
logger.debug("bye")
