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._fulldata = 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 setUp(self):
filename = os.path.join(tempfile.gettempdir(), "test.fuzz")
mod1 = Modulator("mod 1")
mod2 = Modulator("mod 2")
mod2.param_for_one = 42
decoders = [
Encoder(["NRZ"]),
Encoder(["NRZ-I", constants.DECODING_INVERT])
]
pac = ProtocolAnalyzerContainer([mod1, mod2])
pac.messages.append(
Message([True, False, False, True, "A"],
100,
decoder=decoders[0],
message_type=pac.default_message_type))
pac.messages.append(
Message([False, False, False, False, "A"],
200,
decoder=decoders[1],
message_type=pac.default_message_type))
pac.used_symbols.add(Symbol("A", 1, 1, 100))
pac.create_fuzzing_label(1, 10, 0)
pac.to_xml_file(filename)
def build_modulator_from_args(arguments: argparse.Namespace):
if arguments.raw:
return None
if arguments.parameter_zero is None:
raise ValueError("You need to give a modulation parameter for zero (-p0, --parameter-zero)")
if arguments.parameter_one is None:
raise ValueError("You need to give a modulation parameter for one (-p1, --parameter-one)")
result = Modulator("CLI Modulator")
result.carrier_freq_hz = float(arguments.carrier_frequency)
result.carrier_amplitude = float(arguments.carrier_amplitude)
result.carrier_phase_deg = float(arguments.carrier_phase)
result.samples_per_bit = int(arguments.bit_length)
if arguments.modulation_type == "ASK":
if arguments.parameter_zero.endswith("%"):
param_zero = float(arguments.parameter_zero[:-1])
else:
param_zero = float(arguments.parameter_zero) * 100
if arguments.parameter_one.endswith("%"):
param_one = float(arguments.parameter_one[:-1])
else:
param_one = float(arguments.parameter_one) * 100
else:
param_zero = float(arguments.parameter_zero)
param_one = float(arguments.parameter_one)
result.param_for_zero = param_zero
result.param_for_one = param_one
result.modulation_type_str = arguments.modulation_type
result.sample_rate = arguments.sample_rate
return result
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_load_profile(self):
filename = os.path.join(tempfile.gettempdir(), "test.fuzz")
mod1 = Modulator("mod 1")
mod2 = Modulator("mod 2")
mod2.param_for_one = 42
decoders = [Encoding(["NRZ"]), Encoding(["NRZ-I", constants.DECODING_INVERT])]
pac = ProtocolAnalyzerContainer([mod1, mod2])
pac.messages.append(Message([True, False, False, True], 100, decoder=decoders[0], message_type=pac.default_message_type))
pac.messages.append(Message([False, False, False, False], 200, decoder=decoders[1], message_type=pac.default_message_type))
pac.create_fuzzing_label(1, 10, 0)
pac.to_xml_file(filename)
self.wait_before_new_file()
self.form.add_files([os.path.join(tempfile.gettempdir(), "test.fuzz")])
self.assertEqual(self.form.ui.tabWidget.currentWidget(), self.form.ui.tab_generator)
pac = self.form.generator_tab_controller.table_model.protocol
self.assertEqual(len(pac.modulators), 2)
self.assertEqual(len(pac.messages), 2)
self.assertEqual(pac.messages[1][0], False)
self.assertEqual(len(pac.protocol_labels), 1)
def build_modulator_from_args(arguments: argparse.Namespace):
if arguments.raw:
return None
if arguments.parameter_zero is None:
raise ValueError("You need to give a modulation parameter for zero (-p0, --parameter-zero)")
if arguments.parameter_one is None:
raise ValueError("You need to give a modulation parameter for one (-p1, --parameter-one)")
result = Modulator("CLI Modulator")
result.carrier_freq_hz = float(arguments.carrier_frequency)
result.carrier_amplitude = float(arguments.carrier_amplitude)
result.carrier_phase_deg = float(arguments.carrier_phase)
result.samples_per_bit = int(arguments.bit_length)
if arguments.modulation_type == "ASK":
if arguments.parameter_zero.endswith("%"):
param_zero = float(arguments.parameter_zero[:-1])
else:
param_zero = float(arguments.parameter_zero) * 100
if arguments.parameter_one.endswith("%"):
param_one = float(arguments.parameter_one[:-1])
else:
param_one = float(arguments.parameter_one) * 100
else:
param_zero = float(arguments.parameter_zero)
param_one = float(arguments.parameter_one)
result.param_for_zero = param_zero
result.param_for_one = param_one
result.modulation_type_str = arguments.modulation_type
result.sample_rate = arguments.sample_rate
return result
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_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_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_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_symbol = 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.iq_array = IQArray.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 = 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 * bit_len), 1)
time.sleep(1)
sniffer.stop()
self.assertEqual(sniffer.plain_bits_str, data)
def test_psk_detection(self):
modulator = Modulator("")
modulator.modulation_type = "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_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_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 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_segmentation_ask_50(self):
modulator = Modulator("ask50")
modulator.modulation_type = "ASK"
modulator.param_for_zero = 50
modulator.param_for_one = 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_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_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_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_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_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 read_modulators_from_file(self, filename: str):
if not filename:
return []
tree = ET.parse(filename)
root = tree.getroot()
result = []
for mod_tag in root.iter("modulator"):
mod = Modulator(mod_tag.attrib["name"])
mod.carrier_freq_hz = float(mod_tag.attrib["carrier_freq_hz"])
mod.carrier_amplitude = float(mod_tag.attrib["carrier_amplitude"])
mod.carrier_phase_deg = float(mod_tag.attrib["carrier_phase_deg"])
mod.modulation_type = int(mod_tag.attrib["modulation_type"])
mod.sample_rate = float(mod_tag.attrib["sample_rate"])
mod.param_for_one = float(mod_tag.attrib["param_for_one"])
mod.param_for_zero = float(mod_tag.attrib["param_for_zero"])
result.append(mod)
return result
def test_load_profile(self):
filename = os.path.join(tempfile.gettempdir(), "test.fuzz.xml")
mod1 = Modulator("mod 1")
mod2 = Modulator("mod 2")
mod2.param_for_one = 42
decoders = [
Encoding(["NRZ"]),
Encoding(["NRZ-I", constants.DECODING_INVERT])
]
pac = ProtocolAnalyzerContainer()
pac.messages.append(
Message([True, False, False, True],
100,
decoder=decoders[0],
message_type=pac.default_message_type))
pac.messages.append(
Message([False, False, False, False],
200,
decoder=decoders[1],
message_type=pac.default_message_type))
pac.create_fuzzing_label(1, 10, 0)
assert isinstance(self.form, MainController)
pac.to_xml_file(filename,
decoders=decoders,
participants=self.form.project_manager.participants)
self.wait_before_new_file()
self.form.add_files(
[os.path.join(tempfile.gettempdir(), "test.fuzz.xml")])
self.assertEqual(self.form.ui.tabWidget.currentWidget(),
self.form.ui.tab_generator)
pac = self.form.generator_tab_controller.table_model.protocol
self.assertEqual(len(pac.messages), 2)
self.assertEqual(pac.messages[1][0], False)
self.assertEqual(len(pac.protocol_labels), 1)
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)
chunk_size = 128
for i in range(0, len(send_data), chunk_size):
self.network_sdr_plugin_sender.send_raw_data(
send_data[i:i + chunk_size], 1)
QTest.qWait(10)
# Send enough pauses to end sniffing
for i in range(10):
self.network_sdr_plugin_sender.send_raw_data(
np.zeros(bit_len, dtype=np.complex64), 1)
QTest.qWait(10)
sniffer.stop()
self.assertEqual(sniffer.plain_bits_str, data)
# needed to prevent crash on windows
QTest.qWait(10)
dtype=np.complex64)[86452:115541]
# data = np.fromfile("/home/joe/GIT/urh/tests/data/action_ook.complex", dtype=np.complex64)[3780:4300]
# data = np.fromfile("/home/joe/GIT/urh/tests/data/ask50.complex", dtype=np.complex64)
# Wavelet transform the data
# data = np.fromfile("/home/joe/GIT/urh/tests/data/ask.complex", dtype=np.complex64)[0:2 ** 13]
# data = np.fromfile("/tmp/generated.complex", dtype=np.complex64)
# data = np.fromfile("/tmp/psk.complex", dtype=np.complex64)
# data = np.fromfile("/home/joe/GIT/urh/tests/data/psk_generated.complex", dtype=np.complex64)[0:8000]
modulator = Modulator("")
modulator.modulation_type_str = "PSK"
modulator.param_for_zero = 0
modulator.param_for_one = 180
modulator.carrier_freq_hz = 5e3
modulator.sample_rate = 200e3
# data = modulator.modulate("1010", pause=0)
# data = np.fromfile("/tmp/ask25.complex", dtype=np.complex64)
# data = np.fromfile("/tmp/ask1080.complex", dtype=np.complex64)
scale = 4
median_filter_order = 11
data = data[np.abs(data) > 0]
# Normalize with max of data to prevent increasing variance for signals with lower amplitude
data = data / np.abs(np.max(data))
mag_wvlt = np.abs(cwt_haar(data, scale=scale))
dtype=np.complex64)[86452:115541]
# data = np.fromfile("/home/joe/GIT/urh/tests/data/action_ook.complex", dtype=np.complex64)[3780:4300]
# data = np.fromfile("/home/joe/GIT/urh/tests/data/ask50.complex", dtype=np.complex64)
# Wavelet transform the data
# data = np.fromfile("/home/joe/GIT/urh/tests/data/ask.complex", dtype=np.complex64)[0:2 ** 13]
# data = np.fromfile("/tmp/generated.complex", dtype=np.complex64)
# data = np.fromfile("/tmp/psk.complex", dtype=np.complex64)
# data = np.fromfile("/home/joe/GIT/urh/tests/data/psk_generated.complex", dtype=np.complex64)[0:8000]
modulator = Modulator("")
modulator.modulation_type = "PSK"
modulator.param_for_zero = 0
modulator.param_for_one = 180
modulator.carrier_freq_hz = 5e3
modulator.sample_rate = 200e3
# data = modulator.modulate("1010", pause=0)
# data = np.fromfile("/tmp/ask25.complex", dtype=np.complex64)
# data = np.fromfile("/tmp/ask1080.complex", dtype=np.complex64)
scale = 4
median_filter_order = 11
data = data[np.abs(data) > 0]
# Normalize with max of data to prevent increasing variance for signals with lower amplitude
data = data / np.abs(np.max(data))
mag_wvlt = np.abs(cwt_haar(data, scale=scale))
