def read_project_file_for_signal(self, signal: Signal):
if self.project_file is None or len(signal.filename) == 0:
return False
tree = ET.parse(self.project_file)
root = tree.getroot()
try:
signal_filename = os.path.relpath(signal.filename, self.project_path)
except ValueError:
signal_filename = signal.filename
for sig_tag in root.iter("signal"):
if sig_tag.attrib["filename"] == signal_filename:
signal.name = sig_tag.attrib["name"]
signal.qad_center = float(sig_tag.get("qad_center", 0))
signal.tolerance = int(sig_tag.get("tolerance", 5))
signal.noise_threshold = float(sig_tag.get("noise_threshold", 0.1))
signal.sample_rate = float(sig_tag.get("sample_rate", 1e6))
signal.bit_len = int(sig_tag.get("bit_length", 100))
signal.modulation_type = int(sig_tag.get("modulation_type", 0))
signal.pause_threshold = int(sig_tag.get("pause_threshold", 8))
signal.message_length_divisor = int(sig_tag.get("message_length_divisor", 1))
break
return True
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 __init__(self, bit_len: int, center: float, noise: float, tolerance: int,
modulation_type: int, device: str, backend_handler: BackendHandler):
signal = Signal("", "LiveSignal")
signal.bit_len = bit_len
signal.qad_center = center
signal.noise_threshold = noise
signal.tolerance = tolerance
signal.silent_set_modulation_type(modulation_type)
ProtocolAnalyzer.__init__(self, signal)
QObject.__init__(self, None)
self.backend_handler = backend_handler
self.rcv_device = VirtualDevice(self.backend_handler, device, Mode.receive,
resume_on_full_receive_buffer=True, raw_mode=False)
self.rcv_device.index_changed.connect(self.on_rcv_thread_index_changed)
self.rcv_device.started.connect(self.__emit_started)
self.rcv_device.stopped.connect(self.__emit_stopped)
self.data_cache = []
self.conseq_non_data = 0
self.reading_data = False
self.store_messages = True
self.__sniff_file = ""
self.__store_data = True
def demodulate(signal_data,
mod_type: str,
bit_length,
center,
noise,
tolerance,
decoding=None,
pause_threshold=8):
signal = Signal("", "")
if isinstance(signal_data, IQArray):
signal.iq_array = signal_data
else:
if signal_data.dtype == np.complex64:
signal.iq_array = IQArray(signal_data.view(np.float32))
else:
signal.iq_array = IQArray(signal_data)
signal.modulation_type = mod_type
signal.bit_len = bit_length
signal.qad_center = center
signal.noise_threshold = noise
signal.pause_threshold = pause_threshold
if tolerance is not None:
signal.tolerance = tolerance
pa = ProtocolAnalyzer(signal)
if decoding is not None:
pa.decoder = decoding
pa.get_protocol_from_signal()
return pa.decoded_hex_str
def read_project_file_for_signal(self, signal: Signal):
if self.project_file is None or len(signal.filename) == 0:
return False
tree = ET.parse(self.project_file)
root = tree.getroot()
for sig_tag in root.iter("signal"):
if sig_tag.attrib["filename"] == os.path.relpath(signal.filename,
self.project_path):
signal.name = sig_tag.attrib["name"]
signal.qad_center = float(sig_tag.attrib["zero_treshold"])
signal.tolerance = int(sig_tag.attrib["tolerance"])
signal.auto_detect_on_modulation_changed = False if \
sig_tag.attrib[
"auto_detect_on_modulation_changed"] == 'False' else True
signal.noise_treshold = float(sig_tag.attrib["noise_treshold"])
try:
signal.sample_rate = float(sig_tag.attrib["sample_rate"])
except KeyError:
pass # For old project files
signal.bit_len = int(sig_tag.attrib["bit_length"])
signal.modulation_type = int(sig_tag.attrib["modulation_type"])
break
return True
def __init__(self, bit_len: int, center: float, noise: float, tolerance: int,
modulation_type: int, device: str, backend_handler: BackendHandler, network_raw_mode=False):
signal = Signal("", "LiveSignal")
signal.bit_len = bit_len
signal.qad_center = center
signal.noise_threshold = noise
signal.tolerance = tolerance
signal.silent_set_modulation_type(modulation_type)
ProtocolAnalyzer.__init__(self, signal)
QObject.__init__(self, None)
self.network_raw_mode = network_raw_mode
self.backend_handler = backend_handler
self.rcv_device = VirtualDevice(self.backend_handler, device, Mode.receive,
resume_on_full_receive_buffer=True, raw_mode=network_raw_mode)
self.sniff_thread = Thread(target=self.check_for_data, daemon=True)
self.rcv_device.started.connect(self.__emit_started)
self.rcv_device.stopped.connect(self.__emit_stopped)
self.__buffer = np.zeros(int(self.BUFFER_SIZE_MB * 1000 * 1000 / 8), dtype=np.complex64)
self.__current_buffer_index = 0
self.reading_data = False
self.adaptive_noise = False
self.automatic_center = False
self.pause_length = 0
self.is_running = False
self.store_messages = True
self.__sniff_file = ""
self.__store_data = True
def __init__(self, bit_len: int, center: float, noise: float, tolerance:
int, modulation_type: int, sample_rate: float, freq: float, gain: int,
bandwidth: float, device: str, usrp_ip="192.168.10.2"):
signal = Signal("", "LiveSignal")
signal.bit_len = bit_len
signal.qad_center = center
signal.noise_threshold = noise
signal.tolerance = tolerance
signal.silent_set_modulation_type(modulation_type)
ProtocolAnalyzer.__init__(self, signal)
QObject.__init__(self, None)
self.backend_handler = BackendHandler()
self.rcv_device = VirtualDevice(self.backend_handler, device, Mode.receive, bandwidth, freq, gain, sample_rate, device_ip=usrp_ip, is_ringbuffer=True)
self.rcv_device.index_changed.connect(self.on_rcv_thread_index_changed)
self.rcv_device.started.connect(self.__emit_started)
self.rcv_device.stopped.connect(self.__emit_stopped)
self.rcv_timer = QTimer()
self.rcv_timer.setInterval(1000)
self.rcv_timer.timeout.connect(self.on_rcv_timer_timeout)
self.rel_symbol_len = self._read_symbol_len()
self.data_cache = []
self.conseq_non_data = 0
self.reading_data = False
self.store_messages = True
self.__sniff_file = ""
self.__store_data = True
def __init__(self, bit_len: int, center: float, noise: float,
tolerance: int, modulation_type: int, device: str,
backend_handler: BackendHandler):
signal = Signal("", "LiveSignal")
signal.bit_len = bit_len
signal.qad_center = center
signal.noise_threshold = noise
signal.tolerance = tolerance
signal.silent_set_modulation_type(modulation_type)
ProtocolAnalyzer.__init__(self, signal)
QObject.__init__(self, None)
self.backend_handler = backend_handler
self.rcv_device = VirtualDevice(self.backend_handler,
device,
Mode.receive,
is_ringbuffer=False,
raw_mode=False)
self.rcv_device.index_changed.connect(self.on_rcv_thread_index_changed)
self.rcv_device.started.connect(self.__emit_started)
self.rcv_device.stopped.connect(self.__emit_stopped)
self.data_cache = []
self.conseq_non_data = 0
self.reading_data = False
self.store_messages = True
self.__sniff_file = ""
self.__store_data = True
def read_project_file_for_signal(self, signal: Signal):
if self.project_file is None or len(signal.filename) == 0:
return False
tree = ET.parse(self.project_file)
root = tree.getroot()
for sig_tag in root.iter("signal"):
if sig_tag.attrib["filename"] == os.path.relpath(
signal.filename, self.project_path):
signal.name = sig_tag.attrib["name"]
signal.qad_center = float(sig_tag.get("qad_center", 0))
signal.tolerance = int(sig_tag.get("tolerance", 5))
signal.auto_detect_on_modulation_changed = False if \
sig_tag.attrib[
"auto_detect_on_modulation_changed"] == 'False' else True
signal.noise_threshold = float(
sig_tag.get("noise_threshold", 0.1))
signal.sample_rate = float(sig_tag.get("sample_rate", 1e6))
signal.bit_len = int(sig_tag.get("bit_length", 100))
signal.modulation_type = int(sig_tag.get("modulation_type", 0))
signal.pause_threshold = int(sig_tag.get("pause_threshold", 8))
signal.message_length_divisor = int(
sig_tag.get("message_length_divisor", 1))
break
return True
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(self):
signal = Signal(get_path_for_data_file("psk_gen_noisy.complex"), "PSK-Test")
signal.modulation_type = "PSK"
signal.samples_per_symbol = 300
signal.center = 0
signal.noise_threshold = 0
signal.tolerance = 10
proto_analyzer = ProtocolAnalyzer(signal)
proto_analyzer.get_protocol_from_signal()
self.assertTrue(proto_analyzer.plain_bits_str[0].startswith("1011"), msg=proto_analyzer.plain_bits_str[0])
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_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_ask_two(self):
signal = Signal(get_path_for_data_file("ask_short.complex"), "ASK-Test2")
signal.modulation_type = "ASK"
signal.noise_threshold = 0.0299
signal.samples_per_symbol = 16
signal.center = 0.1300
signal.tolerance = 0
self.assertEqual(signal.num_samples, 131)
proto_analyzer = ProtocolAnalyzer(signal)
proto_analyzer.get_protocol_from_signal()
self.assertEqual(proto_analyzer.plain_bits_str[0], "10101010")
def __init__(self,
samples_per_symbol: int,
center: float,
center_spacing: float,
noise: float,
tolerance: int,
modulation_type: str,
bits_per_symbol: int,
device: str,
backend_handler: BackendHandler,
network_raw_mode=False):
signal = Signal("", "LiveSignal")
signal.samples_per_symbol = samples_per_symbol
signal.center = center
signal.center_spacing = center_spacing
signal.noise_threshold = noise
signal.tolerance = tolerance
signal.silent_set_modulation_type(modulation_type)
signal.bits_per_symbol = bits_per_symbol
ProtocolAnalyzer.__init__(self, signal)
QObject.__init__(self, None)
self.network_raw_mode = network_raw_mode
self.backend_handler = backend_handler
self.rcv_device = VirtualDevice(self.backend_handler,
device,
Mode.receive,
resume_on_full_receive_buffer=True,
raw_mode=network_raw_mode)
signal.iq_array = IQArray(None, self.rcv_device.data_type, 0)
self.sniff_thread = Thread(target=self.check_for_data, daemon=True)
self.rcv_device.started.connect(self.__emit_started)
self.rcv_device.stopped.connect(self.__emit_stopped)
self.__buffer = IQArray(None, np.float32, 0)
self.__init_buffer()
self.__current_buffer_index = 0
self.reading_data = False
self.adaptive_noise = False
self.automatic_center = False
self.pause_length = 0
self.is_running = False
self.store_messages = True
self.__sniff_file = ""
self.__store_data = True
def demodulate(signal_data, mod_type: str, bit_length, center, noise, tolerance, decoding=None, pause_threshold=8):
signal = Signal("", "")
signal._fulldata = signal_data
signal.modulation_type = signal.MODULATION_TYPES.index(mod_type)
signal.bit_len = bit_length
signal.qad_center = center
signal.noise_threshold = noise
signal.pause_threshold = pause_threshold
if tolerance is not None:
signal.tolerance = tolerance
pa = ProtocolAnalyzer(signal)
if decoding is not None:
pa.decoder = decoding
pa.get_protocol_from_signal()
return pa.decoded_hex_str
def read_project_file_for_signal(self, signal: Signal):
if self.project_file is None or len(signal.filename) == 0:
return False
tree = ET.parse(self.project_file)
root = tree.getroot()
try:
signal_filename = os.path.relpath(signal.filename,
self.project_path)
except ValueError:
signal_filename = signal.filename
for sig_tag in root.iter("signal"):
if sig_tag.attrib["filename"] == signal_filename:
signal.name = sig_tag.attrib["name"]
center = sig_tag.get("qad_center", None) # legacy support
signal.center = float(sig_tag.get(
"center", 0)) if center is None else float(center)
signal.center_spacing = float(
sig_tag.get("center_spacing", 0.1))
signal.tolerance = int(sig_tag.get("tolerance", 5))
signal.bits_per_symbol = int(sig_tag.get("bits_per_symbol", 1))
signal.costas_loop_bandwidth = float(
sig_tag.get("costas_loop_bandwidth", 0.1))
signal.noise_threshold = float(
sig_tag.get("noise_threshold", 0.1))
signal.sample_rate = float(sig_tag.get("sample_rate", 1e6))
signal.samples_per_symbol = int(sig_tag.get(
"bit_length", 0)) # Legacy for old project files
if signal.samples_per_symbol == 0:
signal.samples_per_symbol = int(
sig_tag.get("samples_per_symbol", 100))
try:
# Legacy support when modulation type was integer
signal.modulation_type = Signal.MODULATION_TYPES[int(
sig_tag.get("modulation_type", 0))]
except (ValueError, IndexError):
signal.modulation_type = sig_tag.get(
"modulation_type", "ASK")
signal.pause_threshold = int(sig_tag.get("pause_threshold", 8))
signal.message_length_divisor = int(
sig_tag.get("message_length_divisor", 1))
break
return True
def __init__(self,
bit_len: int,
center: float,
noise: float,
tolerance: int,
modulation_type: int,
sample_rate: float,
freq: float,
gain: int,
bandwidth: float,
device: str,
usrp_ip="192.168.10.2"):
signal = Signal("", "LiveSignal")
signal.bit_len = bit_len
signal.qad_center = center
signal.noise_treshold = noise
signal.tolerance = tolerance
signal.silent_set_modulation_type(modulation_type)
super().__init__(signal)
self.rcv_thrd = ReceiverThread(sample_rate,
freq,
gain,
bandwidth,
initial_bufsize=1e8,
is_ringbuffer=True)
self.rcv_thrd.usrp_ip = usrp_ip
self.rcv_thrd.device = device
self.rcv_thrd.index_changed.connect(self.on_rcv_thread_index_changed)
self.rcv_timer = QTimer()
self.rcv_timer.setInterval(1000)
self.rcv_timer.timeout.connect(self.on_rcv_timer_timeout)
self.rel_symbol_len = self._read_symbol_len()
self.data_cache = []
self.conseq_non_data = 0
self.reading_data = False
self.store_blocks = True
self.__sniff_file = ""
self.__store_data = True
def __init__(self,
bit_len: int,
center: float,
noise: float,
tolerance: int,
modulation_type: int,
device: str,
backend_handler: BackendHandler,
network_raw_mode=False):
signal = Signal("", "LiveSignal")
signal.bit_len = bit_len
signal.qad_center = center
signal.noise_threshold = noise
signal.tolerance = tolerance
signal.silent_set_modulation_type(modulation_type)
ProtocolAnalyzer.__init__(self, signal)
QObject.__init__(self, None)
self.network_raw_mode = network_raw_mode
self.backend_handler = backend_handler
self.rcv_device = VirtualDevice(self.backend_handler,
device,
Mode.receive,
resume_on_full_receive_buffer=True,
raw_mode=network_raw_mode)
self.rcv_device.emit_data_received_signal = True
self.rcv_device.data_received.connect(self.on_data_received)
self.rcv_device.started.connect(self.__emit_started)
self.rcv_device.stopped.connect(self.__emit_stopped)
self.real_time = real_time
self.data_cache = []
self.reading_data = False
self.adaptive_noise = False
self.pause_length = 0
self.store_messages = True
self.__sniff_file = ""
self.__store_data = True
def demodulate(signal_data,
mod_type: str,
bit_length,
center,
noise,
tolerance,
decoding=None,
pause_threshold=8):
signal = Signal("", "")
signal._fulldata = signal_data
signal.modulation_type = signal.MODULATION_TYPES.index(mod_type)
signal.bit_len = bit_length
signal.qad_center = center
signal.noise_threshold = noise
signal.pause_threshold = pause_threshold
if tolerance is not None:
signal.tolerance = tolerance
pa = ProtocolAnalyzer(signal)
if decoding is not None:
pa.decoder = decoding
pa.get_protocol_from_signal()
return pa.decoded_hex_str
def read_project_file_for_signal(self, signal: Signal):
if self.project_file is None or len(signal.filename) == 0:
return False
tree = ET.parse(self.project_file)
root = tree.getroot()
for sig_tag in root.iter("signal"):
if sig_tag.attrib["filename"] == os.path.relpath(signal.filename,
self.project_path):
signal.name = sig_tag.attrib["name"]
signal.qad_center = float(sig_tag.get("qad_center", 0))
signal.tolerance = int(sig_tag.get("tolerance", 5))
signal.auto_detect_on_modulation_changed = False if \
sig_tag.attrib[
"auto_detect_on_modulation_changed"] == 'False' else True
signal.noise_threshold = float(sig_tag.get("noise_threshold", 0.1))
signal.sample_rate = float(sig_tag.get("sample_rate", 1e6))
signal.bit_len = int(sig_tag.get("bit_length", 100))
signal.modulation_type = int(sig_tag.get("modulation_type", 0))
break
return True
