mirror of
https://github.com/jopohl/urh.git
synced 2026-03-12 03:06:50 +01:00
26e5bbb492
* add argument parser for CLI * add pause to cli * parse messages to send * add send function * use while loop instead of hard sleep * use logger for error msg * use tabulator for progress bar * prepare rx mode * use Thread for Protocol Sniffer instead of qt signals * adapt tests * fix thread can only be started once error * enable receiving from command line * support send from file * save gain correctly * enable rx into file * remove unused signal * enable raw rx and file mode * add support for device identifier * add support for default pause * enable abort sending witt ctrl c * support encodings * make logging multiprocessing aware and add autobuild extensions to cli * move place * fix sniffer when receiving multiple messages at once * add test for modulator cli parsing and fix some bugs * extend modulator test and fix another bug * add unittests and reorder urh_cli structure * add tests * adapt CI to CLI tests * force osx * fix osx * adapt close dialog method * remove close dialog method * test read messages to send * centralize read messages method * increase timeout for ci * support loading of project files to load cli values * add sleep for ci * add cli to deployment * replace static calls with ProjectManager Class * use time sleep instead of qwait * disable gc collect call * disable gc collect for python 3.4 only * gc collect only for osx * simplify cleanup * simplify cleanup * advanced cleanup only for windows * cleanup also for osx * gc collect for osx * add unittests * consider frozen app path * init multiprocessing first * enable logging on cli for windows * use log file handler for log * add missing import
194 lines
9.6 KiB
Python
194 lines
9.6 KiB
Python
import os
|
|
import platform
|
|
import sys
|
|
import tempfile
|
|
import unittest
|
|
from urh.dev.VirtualDevice import Mode
|
|
from urh.dev.BackendHandler import Backends
|
|
|
|
from urh.cli import urh_cli
|
|
|
|
|
|
class TestCLIParsing(unittest.TestCase):
|
|
def setUp(self):
|
|
self.parser = urh_cli.create_parser()
|
|
|
|
def test_build_modulator_from_args(self):
|
|
args = self.parser.parse_args("--device HackRF --frequency 433.92e6 --sample-rate 2e6 --raw".split())
|
|
self.assertIsNone(urh_cli.build_modulator_from_args(args))
|
|
|
|
args = self.parser.parse_args("--device HackRF --frequency 433.92e6 --sample-rate 2e6".split())
|
|
with self.assertRaises(ValueError):
|
|
urh_cli.build_modulator_from_args(args)
|
|
|
|
args = self.parser.parse_args("--device HackRF --frequency 433.92e6 --sample-rate 2e6 -p0 0".split())
|
|
with self.assertRaises(ValueError):
|
|
urh_cli.build_modulator_from_args(args)
|
|
|
|
args = self.parser.parse_args("--device HackRF --frequency 433.92e6 --sample-rate 2e6"
|
|
" -p0 0 -p1 1 -mo ASK -cf 1337e3 -ca 0.9 -bl 24 -cp 30".split())
|
|
modulator = urh_cli.build_modulator_from_args(args)
|
|
self.assertEqual(modulator.modulation_type_str, "ASK")
|
|
self.assertEqual(modulator.sample_rate, 2e6)
|
|
self.assertEqual(modulator.samples_per_bit, 24)
|
|
self.assertEqual(modulator.param_for_zero, 0)
|
|
self.assertEqual(modulator.param_for_one, 100)
|
|
self.assertEqual(modulator.carrier_freq_hz, 1337e3)
|
|
self.assertEqual(modulator.carrier_amplitude, 0.9)
|
|
self.assertEqual(modulator.carrier_phase_deg, 30)
|
|
|
|
|
|
args = self.parser.parse_args("--device HackRF --frequency 433.92e6 --sample-rate 2e6"
|
|
" -p0 10% -p1 20% -mo ASK -cf 1337e3 -ca 0.9 -bl 24 -cp 30".split())
|
|
modulator = urh_cli.build_modulator_from_args(args)
|
|
self.assertEqual(modulator.param_for_zero, 10)
|
|
self.assertEqual(modulator.param_for_one, 20)
|
|
|
|
args = self.parser.parse_args("--device HackRF --frequency 433.92e6 --sample-rate 2e6"
|
|
" -p0 20e3 -p1=-20e3 -mo FSK -cf 1337e3 -ca 0.9 -bl 24 -cp 30".split())
|
|
modulator = urh_cli.build_modulator_from_args(args)
|
|
self.assertEqual(modulator.modulation_type_str, "FSK")
|
|
self.assertEqual(modulator.param_for_zero, 20e3)
|
|
self.assertEqual(modulator.param_for_one, -20e3)
|
|
|
|
def test_build_backend_handler_from_args(self):
|
|
args = self.parser.parse_args("--device USRP --frequency 433.92e6 --sample-rate 2e6".split())
|
|
bh = urh_cli.build_backend_handler_from_args(args)
|
|
self.assertEqual(bh.device_backends["usrp"].selected_backend, Backends.native)
|
|
|
|
args = self.parser.parse_args("--device HackRF --frequency 433.92e6 --sample-rate 2e6"
|
|
" --device-backend native".split())
|
|
bh = urh_cli.build_backend_handler_from_args(args)
|
|
self.assertEqual(bh.device_backends["hackrf"].selected_backend, Backends.native)
|
|
|
|
args = self.parser.parse_args("--device RTL-SDR --frequency 433.92e6 --sample-rate 2e6"
|
|
" --device-backend gnuradio".split())
|
|
bh = urh_cli.build_backend_handler_from_args(args)
|
|
self.assertEqual(bh.device_backends["rtl-sdr"].selected_backend, Backends.grc)
|
|
|
|
|
|
def test_build_device_from_args(self):
|
|
if sys.platform == "win32" and platform.architecture()[0] == "32bit":
|
|
# no device extensions on 32 bit windows
|
|
return
|
|
|
|
args = self.parser.parse_args("--device HackRF --frequency 133.7e6 --sample-rate 2.5e6 -rx "
|
|
"-if 24 -bb 30 -g 0 --device-identifier abcde".split())
|
|
device = urh_cli.build_device_from_args(args)
|
|
self.assertEqual(device.sample_rate, 2.5e6)
|
|
self.assertEqual(device.bandwidth, 2.5e6)
|
|
self.assertEqual(device.name, "HackRF")
|
|
self.assertEqual(device.backend, Backends.native)
|
|
self.assertEqual(device.frequency, 133.7e6)
|
|
self.assertEqual(device.mode, Mode.receive)
|
|
self.assertEqual(device.if_gain, 24)
|
|
self.assertEqual(device.gain, 0)
|
|
self.assertEqual(device.baseband_gain, 30)
|
|
self.assertEqual(device.device_serial, "abcde")
|
|
|
|
args = self.parser.parse_args("--device RTL-SDR --frequency 133.7e6 --sample-rate 1e6 "
|
|
"-rx -db native --device-identifier 42".split())
|
|
device = urh_cli.build_device_from_args(args)
|
|
self.assertEqual(device.sample_rate, 1e6)
|
|
self.assertEqual(device.name, "RTL-SDR")
|
|
self.assertEqual(device.backend, Backends.native)
|
|
self.assertEqual(device.frequency, 133.7e6)
|
|
self.assertEqual(device.mode, Mode.receive)
|
|
self.assertEqual(device.device_number, 42)
|
|
|
|
args = self.parser.parse_args("--device HackRF --frequency 133.7e6 --sample-rate 2.5e6 --bandwidth 5e6 "
|
|
"-tx -db gnuradio".split())
|
|
device = urh_cli.build_device_from_args(args)
|
|
self.assertEqual(device.sample_rate, 2.5e6)
|
|
self.assertEqual(device.bandwidth, 5e6)
|
|
self.assertEqual(device.name, "HackRF")
|
|
self.assertEqual(device.backend, Backends.grc)
|
|
self.assertEqual(device.frequency, 133.7e6)
|
|
self.assertEqual(device.mode, Mode.send)
|
|
|
|
def test_build_protocol_sniffer_from_args(self):
|
|
if sys.platform == "win32" and platform.architecture()[0] == "32bit":
|
|
# no device extensions on 32 bit windows
|
|
return
|
|
|
|
args = self.parser.parse_args("--device HackRF --frequency 50e3 --sample-rate 2.5e6 -rx "
|
|
"-if 24 -bb 30 -g 0 --device-identifier abcde "
|
|
"-bl 1337 --center 0.5 --noise 0.1234 --tolerance 42".split())
|
|
sniffer = urh_cli.build_protocol_sniffer_from_args(args)
|
|
self.assertEqual(sniffer.rcv_device.frequency, 50e3)
|
|
self.assertEqual(sniffer.rcv_device.sample_rate, 2.5e6)
|
|
self.assertEqual(sniffer.rcv_device.bandwidth, 2.5e6)
|
|
self.assertEqual(sniffer.rcv_device.name, "hackrf")
|
|
self.assertEqual(sniffer.rcv_device.backend, Backends.native)
|
|
self.assertEqual(sniffer.rcv_device.mode, Mode.receive)
|
|
self.assertEqual(sniffer.rcv_device.if_gain, 24)
|
|
self.assertEqual(sniffer.rcv_device.gain, 0)
|
|
self.assertEqual(sniffer.rcv_device.baseband_gain, 30)
|
|
self.assertEqual(sniffer.rcv_device.device_serial, "abcde")
|
|
self.assertEqual(sniffer.signal.bit_len, 1337)
|
|
self.assertEqual(sniffer.signal.noise_threshold, 0.1234)
|
|
self.assertEqual(sniffer.signal.qad_center, 0.5)
|
|
self.assertEqual(sniffer.signal.tolerance, 42)
|
|
|
|
|
|
def test_build_encoding_from_args(self):
|
|
args = self.parser.parse_args('--device HackRF --frequency 50e3 --sample-rate 2.5e6 -e "Test,Invert"'.split())
|
|
encoding = urh_cli.build_encoding_from_args(args)
|
|
self.assertEqual(len(encoding.chain), 2)
|
|
|
|
def test_read_messages_to_send(self):
|
|
args = self.parser.parse_args('--device HackRF --frequency 50e3 --sample-rate 2e6 -rx'.split())
|
|
self.assertIsNone(urh_cli.read_messages_to_send(args))
|
|
|
|
args = self.parser.parse_args('--device HackRF --frequency 50e3 --sample-rate 2e6 -tx'.split())
|
|
with self.assertRaises(SystemExit):
|
|
urh_cli.read_messages_to_send(args)
|
|
|
|
|
|
args = self.parser.parse_args('--device HackRF --frequency 50e3 --sample-rate 2e6 -tx '
|
|
'-file /tmp/test -m 1111'.split())
|
|
with self.assertRaises(SystemExit):
|
|
urh_cli.read_messages_to_send(args)
|
|
|
|
test_messages = ["101010/1s", "10000/50ms", "00001111/100.5µs", "111010101/500ns", "1111001", "111110000/2000"]
|
|
args = self.parser.parse_args(('--device HackRF --frequency 50e3 --sample-rate 2e6 -tx --pause 1337 '
|
|
'-m '+" ".join(test_messages)).split())
|
|
messages = urh_cli.read_messages_to_send(args)
|
|
self.assertEqual(len(messages), len(test_messages))
|
|
self.assertEqual(messages[0].decoded_bits_str, "101010")
|
|
self.assertEqual(messages[0].pause, 2e6)
|
|
|
|
self.assertEqual(messages[1].decoded_bits_str, "10000")
|
|
self.assertEqual(messages[1].pause, 100e3)
|
|
|
|
self.assertEqual(messages[2].decoded_bits_str, "00001111")
|
|
self.assertEqual(messages[2].pause, 201)
|
|
|
|
self.assertEqual(messages[3].decoded_bits_str, "111010101")
|
|
self.assertEqual(messages[3].pause, 1)
|
|
|
|
self.assertEqual(messages[4].decoded_bits_str, "1111001")
|
|
self.assertEqual(messages[4].pause, 1337)
|
|
|
|
self.assertEqual(messages[5].decoded_bits_str, "111110000")
|
|
self.assertEqual(messages[5].pause, 2000)
|
|
|
|
test_messages = ["aabb/2s"]
|
|
filepath = tempfile.mktemp()
|
|
with open(filepath, "w") as f:
|
|
f.write("\n".join(test_messages))
|
|
|
|
args = self.parser.parse_args(('--device HackRF --frequency 50e3 --sample-rate 2e6 -tx --pause 1337 --hex '
|
|
'-file '+filepath).split())
|
|
messages = urh_cli.read_messages_to_send(args)
|
|
self.assertEqual(len(messages), len(test_messages))
|
|
self.assertEqual(messages[0].decoded_bits_str, "1010101010111011")
|
|
self.assertEqual(messages[0].pause, 4e6)
|
|
|
|
def test_parse_project_file(self):
|
|
f = os.readlink(__file__) if os.path.islink(__file__) else __file__
|
|
path = os.path.realpath(os.path.join(f, ".."))
|
|
project_file = os.path.join(path, "..", "data", "URHProject.xml")
|
|
project_params = urh_cli.parse_project_file(project_file)
|
|
self.assertGreater(len(project_params), 0)
|