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 test_4_psk(self): bits = array.array("B", [1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1]) angles_degree = [-135, -45, 45, 135] parameters = array.array("f", [np.pi*a/180 for a in angles_degree]) result = modulate_c(bits, 100, "PSK", parameters, 2, 1, 40e3, 0, 1e6, 1000, 0) signal = Signal("") signal.iq_array = IQArray(result) signal.bits_per_symbol = 2 signal.center = 0 signal.center_spacing = 1 signal.modulation_type = "PSK" proto_analyzer = ProtocolAnalyzer(signal) proto_analyzer.get_protocol_from_signal() demod_bits = proto_analyzer.plain_bits_str[0] self.assertEqual(len(demod_bits), len(bits)) self.assertTrue(demod_bits.startswith("10101010")) np.random.seed(42) noised = result + 0.1 * np.random.normal(loc=0, scale=np.sqrt(2)/2, size=(len(result), 2)) signal.iq_array = IQArray(noised.astype(np.float32)) signal.center_spacing = 1.5 signal.noise_threshold = 0.2 signal._qad = None proto_analyzer.get_protocol_from_signal() demod_bits = proto_analyzer.plain_bits_str[0] self.assertEqual(len(demod_bits), len(bits)) self.assertTrue(demod_bits.startswith("10101010"))
def __demodulate(self, connection: socket.socket): connection.settimeout(self.TIMEOUT) time.sleep(self.TIMEOUT) total_data = [] while True: try: data = connection.recv(65536) if data: total_data.append(data) else: break except socket.timeout: break if len(total_data) == 0: logger.error("Did not receive any data from socket.") arr = IQArray( np.array(np.frombuffer(b"".join(total_data), dtype=np.complex64))) signal = Signal("", "") signal.iq_array = arr pa = ProtocolAnalyzer(signal) pa.get_protocol_from_signal() return pa.plain_bits_str
def test_cli_modulate_messages(self): modulator = Modulator("test") modulator.sample_rate = 2e3 modulator.samples_per_bit = 100 modulator.modulation_type_str = "ASK" modulator.param_for_zero = 0 modulator.param_for_one = 100 bits = "1010111100001" self.assertIsNone(urh_cli.modulate_messages([], modulator)) message = Message.from_plain_bits_str(bits, pause=1000) modulated = urh_cli.modulate_messages([message], modulator) # Demodulate for testing s = Signal("", "", modulation="ASK", sample_rate=2e6) s.bit_len = 100 s.noise_threshold = 0 s.iq_array = modulated pa = ProtocolAnalyzer(s) pa.get_protocol_from_signal() self.assertEqual(len(pa.messages), 1) self.assertEqual(pa.messages[0].plain_bits_str, bits)
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, project_manager, modulated_data, modulation_msg_indices=None, continuous_send_mode=False, parent=None, testing_mode=False): super().__init__(project_manager, is_tx=True, continuous_send_mode=continuous_send_mode, parent=parent, testing_mode=testing_mode) self.graphics_view = self.ui.graphicsViewSend self.ui.stackedWidget.setCurrentWidget(self.ui.page_send) self.hide_receive_ui_items() self.ui.btnStart.setIcon(QIcon.fromTheme("media-playback-start")) self.setWindowTitle("Send Signal") self.setWindowIcon(QIcon.fromTheme("media-playback-start")) self.ui.btnStart.setToolTip("Send data") self.ui.btnStop.setToolTip("Stop sending") self.device_is_sending = False self.modulation_msg_indices = modulation_msg_indices if self.modulation_msg_indices is not None: self.ui.progressBarMessage.setMaximum( len(self.modulation_msg_indices)) else: self.ui.progressBarMessage.hide() self.ui.labelCurrentMessage.hide() if modulated_data is not None: assert isinstance(modulated_data, IQArray) # modulated_data is none in continuous send mode self.ui.progressBarSample.setMaximum(len(modulated_data)) samp_rate = self.device_settings_widget.ui.spinBoxSampleRate.value( ) signal = Signal("", "Modulated Preview", sample_rate=samp_rate) signal.iq_array = modulated_data self.scene_manager = SignalSceneManager(signal, parent=self) self.send_indicator = self.scene_manager.scene.addRect( 0, -2, 0, 4, QPen(QColor(Qt.transparent), 0), QBrush(constants.SEND_INDICATOR_COLOR)) self.send_indicator.stackBefore( self.scene_manager.scene.selection_area) self.scene_manager.init_scene() self.graphics_view.set_signal(signal) self.graphics_view.sample_rate = samp_rate self.create_connects() self.device_settings_widget.update_for_new_device( overwrite_settings=False)
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 test_4_fsk(self): bits = array.array("B", [1, 0, 1, 0, 1, 1, 0, 0, 0, 1]) parameters = array.array("f", [-20e3, -10e3, 10e3, 20e3]) result = modulate_c(bits, 100, "FSK", parameters, 2, 1, 40e3, 0, 1e6, 1000, 0, parameters[0]) signal = Signal("") signal.iq_array = IQArray(result) signal.bits_per_symbol = 2 signal.qad_center = 0 proto_analyzer = ProtocolAnalyzer(signal) proto_analyzer.get_protocol_from_signal() self.assertEqual(proto_analyzer.plain_bits_str[0], "1010110001")
def test_fsk_short_bit_length(self): bits_str = "101010" bits = array.array("B", list(map(int, bits_str))) parameters = array.array("f", [-10e3, 10e3]) result = modulate_c(bits, 8, "FSK", parameters, 1, 1, 40e3, 0, 1e6, 1000, 0) signal = Signal("") signal.iq_array = IQArray(result) # Ensure we have no spikes self.assertLess(np.max(signal.qad), 1) signal.qad_center = 0 signal.samples_per_symbol = 8 proto_analyzer = ProtocolAnalyzer(signal) proto_analyzer.get_protocol_from_signal() self.assertEqual(proto_analyzer.plain_bits_str[0], bits_str)