示例#1
0
    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
示例#2
0
    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)
示例#3
0
 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)
示例#4
0
 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)
示例#5
0
 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())
示例#6
0
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
示例#7
0
 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)
示例#8
0
    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
示例#9
0
 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())
示例#10
0
 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)
示例#11
0
    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"))
示例#12
0
    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
示例#13
0
 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)
示例#14
0
    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
示例#15
0
 def test_auto_detect_elektromaten(self):
     signal = Signal("./data/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)
示例#16
0
 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)
示例#17
0
 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)
示例#18
0
 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.0387 < signal.qad_center < 0.1183)
     signal.bit_len = signal.estimate_bitlen()
     self.assertTrue(270 <= signal.bit_len <= 330)
示例#19
0
    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)
示例#20
0
    def test_fsk(self):
        signal = Signal(get_path_for_data_file("fsk.complex"), "FSK-Test")
        signal.modulation_type = "FSK"
        signal.samples_per_symbol = 100
        signal.center = 0

        proto_analyzer = ProtocolAnalyzer(signal)
        proto_analyzer.get_protocol_from_signal()
        self.assertEqual(proto_analyzer.plain_bits_str[0],
                         "101010101010101010101010101010101100011000100110110001100010011011110100110111000001110110011000111011101111011110100100001001111001100110011100110100100011100111010011111100011")
示例#21
0
    def test_ask(self):
        signal = Signal(get_path_for_data_file("ask.complex"), "ASK-Test")
        signal.modulation_type = "ASK"
        signal.samples_per_symbol = 295
        signal.center = 0.0219
        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"))
示例#22
0
    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_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)
示例#24
0
    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"))
示例#25
0
    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")
示例#26
0
    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])
示例#27
0
    def test_get_bit_sample_pos(self):
        signal = Signal(get_path_for_data_file("ASK_mod.complex"),
                        "Bit sample pos test")
        signal.modulation_type = "ASK"
        signal.samples_per_symbol = 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)
示例#28
0
    def test_get_bit_sample_pos(self):
        signal = Signal("./data/ASK_mod.complex", "Bit sample pos test")
        QTest.qWait(10)
        signal.modulation_type = 0
        signal.bit_len = 100

        proto_analyzer = ProtocolAnalyzer(signal)
        proto_analyzer.get_protocol_from_signal()
        self.assertEqual(proto_analyzer.num_blocks, 1)
        for i, pos in enumerate(proto_analyzer.bit_sample_pos[0]):
            self.assertLess(pos, signal.num_samples, msg = i)
示例#29
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")
示例#30
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")
示例#31
0
文件: PlotTests.py 项目: jopohl/urh
    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))
示例#32
0
    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")
示例#33
0
    def test_carrier_auto_detect(self):
        signal = Signal(get_path_for_data_file("wsp.complex"), "test")
        signal.modulation_type = "ASK"
        signal.noise_threshold = 0.035
        signal.center = 0.0245
        signal.samples_per_symbol = 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))
示例#34
0
    def test_fsk(self):
        signal = Signal("./data/fsk.complex", "FSK-Test")
        QTest.qWait(100)
        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"
        )
示例#35
0
    def test_get_rssi_of_message(self):
        signal = Signal(get_path_for_data_file("two_participants.complex"), "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)
示例#36
0
    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)
示例#37
0
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
示例#38
0
    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)
示例#39
0
    def test_write_pcap(self):
        signal = Signal(get_path_for_data_file("ask.complex"), "ASK-Test")
        signal.modulation_type = "ASK"
        signal.samples_per_symbol = 295
        signal.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)
示例#40
0
    def test_get_rssi_of_block(self):
        signal = Signal(
            os.path.realpath(
                os.path.join(os.curdir, "data", "two_participants.complex")),
            "RSSI-Test")
        QTest.qWait(10)
        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_blocks, 18)
        blocks = proto_analyzer.blocks
        self.assertLess(blocks[0].rssi, blocks[1].rssi)
        self.assertGreater(blocks[1].rssi, blocks[2].rssi)
        self.assertLess(blocks[2].rssi, blocks[3].rssi)
        self.assertLess(blocks[-2].rssi, blocks[-1].rssi)
示例#41
0
    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)
示例#42
0
    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)
示例#43
0
    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, "/tmp/test.pcap", 1e6)
示例#44
0
    def test_symbols(self):
        old_sym_len = constants.SETTINGS.value('rel_symbol_length', type=int)
        constants.SETTINGS.setValue('rel_symbol_length', 20)  # Set Symbol length for this test
        s = Signal("./data/vw_symbols.complex", "VW")
        s.noise_treshold = 0.0111
        s.qad_center = 0.0470
        s.bit_len = 500
        s.modulation_type = 0  # ASK
        pa = ProtocolAnalyzer(s)
        pa.get_protocol_from_signal()
        block = pa.blocks[0]
        for i in range(255):  # First 255 are bits
            self.assertEqual(type(block[i]), bool)
        for i in range(255, 261):
            self.assertNotEqual(type(block[i]), bool)  # 6 Symbols
            print("Symbol", block[i].name, "NSamples:", block[i].nsamples, "Pulsetype:", block[i].pulsetype)
        symbols = block.plain_bits_str[255:261]
        self.assertEqual(symbols, "ABABAB")

        constants.SETTINGS.setValue('rel_symbol_length', old_sym_len)  # Restore Symbol Length
示例#45
0
    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)
示例#46
0
    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