ua1zbe
/
openwebrxplus
mirror of https://github.com/luarvique/openwebrx
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Updating instructions for various features.

This commit is contained in:
Marat Fayzullin 2024-03-15 23:32:11 -04:00
parent 10c642e102
commit 036a6d8255
1 changed files with 119 additions and 115 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

234
owrx/feature.py
View File

@ -189,11 +189,11 @@ class FeatureDetector(object):
def has_csdr(self): def has_csdr(self):
""" """
OpenWebRX uses the demodulator and pipeline tools provided by the csdr project. Please check out [the project OpenWebRX uses the demodulator and pipeline tools provided by the
page on github](https://github.com/jketterl/csdr) for further details and installation instructions. [CSDR](https://github.com/jketterl/csdr) project. In addition, the
[PyCSDR](https://github.com/jketterl/pycsdr) must be installed to
In addition, the [pycsdr](https://github.com/jketterl/pycsdr) package must be installed to provide provide CSDR Python bindings. The `python3-csdr` package, found in
python bindings for the csdr library. the OpenWebRX repositories, should be all you need.
""" """
required_version = LooseVersion("0.19.0") required_version = LooseVersion("0.19.0")
@ -210,8 +210,10 @@ class FeatureDetector(object):
def has_nmux(self): def has_nmux(self):
""" """
Nmux is another tool provided by the csdr project. It is used for internal multiplexing of the IQ data streams. Nmux is a tool provided by the
If you're missing nmux even though you have csdr installed, please update your csdr version. [CSDR](https://github.com/jketterl/csdr) project and used for
the internal multiplexing of IQ data streams. You can install
the `nmux` package from the OpenWebRX repositories.
""" """
return self.command_is_runnable("nmux --help") return self.command_is_runnable("nmux --help")
@ -236,15 +238,12 @@ class FeatureDetector(object):
def has_digiham(self): def has_digiham(self):
""" """
To use digital voice modes, the digiham package is required. You can find the package and installation OpenWebRX uses the [DigiHAM](https://github.com/jketterl/digiham)
instructions [here](https://github.com/jketterl/digiham). library for the digital voice modes. In addition, the
[PyDigiHAM](https://github.com/jketterl/pydigiham) must
In addition, the [pydigiham](https://github.com/jketterl/pydigiham) package must be installed to provide be installed to provide DigiHAM Python bindings. The
python bindings for the digiham library. `python3-digiham` package, found in the OpenWebRX
repositories, should be all you need.
Please note: there is close interaction between digiham and openwebrx, so older versions will probably not work.
If you have an older verison of digiham installed, please update it along with openwebrx.
As of now, we require version 0.6 of digiham.
""" """
required_version = LooseVersion("0.6") required_version = LooseVersion("0.6")
@ -278,28 +277,28 @@ class FeatureDetector(object):
def has_rtl_connector(self): def has_rtl_connector(self):
""" """
The owrx_connector package offers direct interfacing between your hardware and openwebrx. It allows quicker The [OWRX Connector](https://github.com/jketterl/owrx_connector)
frequency switching, uses less CPU and can even provide more stability in some cases. provides direct interfacing between RTL-SDR hardware and OpenWebRX.
You can install the `owrx-connector` package from the OpenWebRX
You can get it [here](https://github.com/jketterl/owrx_connector). repositories.
""" """
return self._check_owrx_connector("rtl_connector") return self._check_owrx_connector("rtl_connector")
def has_rtl_tcp_connector(self): def has_rtl_tcp_connector(self):
""" """
The owrx_connector package offers direct interfacing between your hardware and openwebrx. It allows quicker The [OWRX Connector](https://github.com/jketterl/owrx_connector)
frequency switching, uses less CPU and can even provide more stability in some cases. provides direct interfacing between networked RTL-SDR hardware and
OpenWebRX. You can install the `owrx-connector` package from the
You can get it [here](https://github.com/jketterl/owrx_connector). OpenWebRX repositories.
""" """
return self._check_owrx_connector("rtl_tcp_connector") return self._check_owrx_connector("rtl_tcp_connector")
def has_soapy_connector(self): def has_soapy_connector(self):
""" """
The owrx_connector package offers direct interfacing between your hardware and openwebrx. It allows quicker The [OWRX Connector](https://github.com/jketterl/owrx_connector)
frequency switching, uses less CPU and can even provide more stability in some cases. provides direct interfacing between Soapy SDR API and OpenWebRX.
You can install the `owrx-connector` package from the OpenWebRX
You can get it [here](https://github.com/jketterl/owrx_connector). repositories.
""" """
return self._check_owrx_connector("soapy_connector") return self._check_owrx_connector("soapy_connector")
@ -422,31 +421,35 @@ class FeatureDetector(object):
def has_m17_demod(self): def has_m17_demod(self):
""" """
The `m17-demod` tool is used to demodulate M17 digital voice signals. OpenWebRX uses the [M17 Demodulator](https://github.com/mobilinkd/m17-cxx-demod)
to demodulate M17 digital voice signals. You can install the
You can find more information [here](https://github.com/mobilinkd/m17-cxx-demod) `m17-demod` package from the OpenWebRX repositories.
""" """
return self.command_is_runnable("m17-demod", 0) return self.command_is_runnable("m17-demod", 0)
def has_direwolf(self): def has_direwolf(self):
""" """
OpenWebRX uses the [direwolf](https://github.com/wb2osz/direwolf) software modem to decode Packet Radio and OpenWebRX uses the [Direwolf](https://github.com/wb2osz/direwolf)
report data back to APRS-IS. Direwolf is available from the package manager on many distributions, or you can software modem to decode Packet Radio and report data back to APRS-IS.
compile it from source. The same software is also used to decode maritime AIS transmissions.
The `direwolf` package is available in most Linux distributions.
""" """
return self.command_is_runnable("direwolf --help") return self.command_is_runnable("direwolf --help")
def has_airspy_rx(self): def has_airspy_rx(self):
""" """
In order to use an Airspy Receiver, you need to install the airspy_rx receiver software. The [Airspy Host](https://github.com/airspy/airspyone_host)
software is required to interface with the Airspy devices.
You can find instructions on how to build and install it
[here](https://github.com/airspy/airspyone_host).
""" """
return self.command_is_runnable("airspy_rx --help") return self.command_is_runnable("airspy_rx --help")
def has_wsjtx(self): def has_wsjtx(self):
""" """
To decode FT8 and other digimodes, you need to install the WSJT-X software suite. Please check the OpenWebRX uses the [WSJT-X](https://wsjt.sourceforge.io/) software
[WSJT-X homepage](https://wsjt.sourceforge.io/) for ready-made packages or instructions suite to decode FT8 and other digital modes. The `wsjtx` package is
on how to build from source. available in most Linux distributions.
""" """
return reduce(and_, map(self.command_is_runnable, ["jt9", "wsprd"]), True) return reduce(and_, map(self.command_is_runnable, ["jt9", "wsprd"]), True)
@ -466,37 +469,48 @@ class FeatureDetector(object):
def has_wsjtx_2_3(self): def has_wsjtx_2_3(self):
""" """
Newer digital modes (e.g. FST4, FST4) require WSJT-X in at least version 2.3. Newer digital modes (e.g. FST4, FST4) require
[WSJT-X](https://wsjt.sourceforge.io/) version 2.3 or higher.
Use the latest `wsjtx` package available in your Linux distribution.
""" """
return self.has_wsjtx() and self._has_wsjtx_version(LooseVersion("2.3")) return self.has_wsjtx() and self._has_wsjtx_version(LooseVersion("2.3"))
def has_wsjtx_2_4(self): def has_wsjtx_2_4(self):
""" """
WSJT-X version 2.4 introduced the Q65 mode. The Q65 digital mode requires
[WSJT-X](https://wsjt.sourceforge.io/) version 2.4 or higher.
Use the latest `wsjtx` package available in your Linux distribution.
""" """
return self.has_wsjtx() and self._has_wsjtx_version(LooseVersion("2.4")) return self.has_wsjtx() and self._has_wsjtx_version(LooseVersion("2.4"))
def has_msk144decoder(self): def has_msk144decoder(self):
""" """
To decode the MSK144 digimode please install the "msk144decoder". See the OpenWebRX uses the
[project page](https://github.com/alexander-sholohov/msk144decoder) for more details. [MSK144 Decoder](https://github.com/alexander-sholohov/msk144decoder)
to decode the MSK144 digital mode. You can install the
`msk144decoder` package from the OpenWebRX repositories.
""" """
return self.command_is_runnable("msk144decoder") return self.command_is_runnable("msk144decoder")
def has_js8(self): def has_js8(self):
""" """
To decode JS8, you will need to install [JS8Call](http://js8call.com/) OpenWebRX uses the [JS8Call](http://js8call.com/) software
to decode JS8 communications. The `js8call` package is
available in most Linux distributions.
Please note that the `js8` command line decoder is not made available on $PATH by some JS8Call package builds. Please note that the `js8` command line decoder is not added
You will need to manually make it available by either linking it to `/usr/bin` or by adding its location to to the $PATH variable by some JS8Call package builds. You may
$PATH. have to make a link to it from the `/usr/bin` folder or add
its location to the $PATH variable.
""" """
return self.command_is_runnable("js8") return self.command_is_runnable("js8")
def has_js8py(self): def has_js8py(self):
""" """
The js8py library is used to decode binary JS8 messages into readable text. More information is available on OpenWebRX uses the [JS8Py](https://github.com/jketterl/js8py)
[its github page](https://github.com/jketterl/js8py). library to decode binary JS8 messages into readable text. You
can install the `python3-js8py` package from the OpenWebRX
repositories.
""" """
required_version = StrictVersion("0.2") required_version = StrictVersion("0.2")
try: try:
@ -508,37 +522,41 @@ class FeatureDetector(object):
def has_alsa(self): def has_alsa(self):
""" """
Some SDR receivers are identifying themselves as a soundcard. In order to read their data, OpenWebRX relies Some SDR receivers identify themselves as sound cards. OpenWebRX relies
on the Alsa library. It is available as a package for most Linux distributions. on the ALSA library to access such receivers. It can be obtained by
installing the `alsa-utils` package in most Linux distributions.
""" """
return self.command_is_runnable("arecord --help") return self.command_is_runnable("arecord --help")
def has_rockprog(self): def has_rockprog(self):
""" """
The "rockprog" executable is required to send commands to your FiFiSDR. It needs to be installed separately. The `rockprog` executable is required to interface with FiFiSDR
devices. You can download and install it from
You can find instructions and downloads [here](https://o28.sischa.net/fifisdr/trac/wiki/De%3Arockprog). [here](https://o28.sischa.net/fifisdr/trac/wiki/De%3Arockprog).
""" """
return self.command_is_runnable("rockprog") return self.command_is_runnable("rockprog")
def has_freedv_rx(self): def has_freedv_rx(self):
""" """
The "freedv\\_rx" executable is required to demodulate FreeDV digital transmissions. It comes together with the The `freedv\\_rx` executable is required to demodulate FreeDV digital
codec2 library, but it's only a supplemental part and not installed by default or contained in its packages. transmissions. It comes as part of the `codec2` library build, but is
To install it, you will need to compile codec2 from source and manually install freedv\\_rx. not installed by default or contained inside the `codec2` packages.
Detailed installation instructions are available on the To obtain it, you will have to compile 'codec2' from the sources and
[OpenWebRX wiki](https://github.com/jketterl/openwebrx/wiki/FreeDV-demodulator-notes). then manually install `freedv\\_rx`. The detailed installation
instructions are available from the
[OpenWebRX Wiki](https://github.com/jketterl/openwebrx/wiki/FreeDV-demodulator-notes).
""" """
return self.command_is_runnable("freedv_rx") return self.command_is_runnable("freedv_rx")
def has_dream(self): def has_dream(self):
""" """
In order to be able to decode DRM broadcasts, OpenWebRX needs the "dream" DRM decoder. OpenWebRX uses the [Dream](https://sourceforge.net/projects/drm/)
software to decode DRM broadcasts. The default version of Dream,
The version supplied by most distributions will not work properly on the command line, so compiling from source supplied in most Linux distributions, will not work with OpenWebRX,
with a custom set of commands is recommended. Detailed installation instructions are available on the so you will have to compile Dream from the sources. The detailed
[OpenWebRX wiki](https://github.com/jketterl/openwebrx/wiki/DRM-demodulator-notes). installation instructions are available from the
[OpenWebRX Wiki](https://github.com/jketterl/openwebrx/wiki/DRM-demodulator-notes).
""" """
return self.command_is_runnable("dream --help", 0) return self.command_is_runnable("dream --help", 0)
@ -552,8 +570,10 @@ class FeatureDetector(object):
def has_hpsdr_connector(self): def has_hpsdr_connector(self):
""" """
In order to use the HPSDR connector, you will need to install [hpsdrconnector] The [HPSDR Connector](https://github.com/jancona/hpsdrconnector)
(https://github.com/jancona/hpsdrconnector). is required to interface OpenWebRX with Hermes Lite 2, Red Pitaya,
and similar networked SDR devices. You can install the
`hpsdrconnector` package from the OpenWebRX repositories.
""" """
return self.command_is_runnable("hpsdrconnector -h") return self.command_is_runnable("hpsdrconnector -h")
@ -567,14 +587,11 @@ class FeatureDetector(object):
def has_codecserver_ambe(self): def has_codecserver_ambe(self):
""" """
Codecserver is used to decode audio data from digital voice modes using the AMBE codec. The [CodecServer](https://github.com/jketterl/codecserver) is used to decode
audio data from digital voice modes using the AMBE codec. This feature checks
You can find more information [here](https://github.com/jketterl/codecserver). for both the `codecserver` executable and the configured AMBE codec. The
`codecserver` package can be found in the OpenWebRX repositories.
NOTE: this feature flag checks both the availability of codecserver as well as the availability of the AMBE
codec in the configured codecserer instance.
""" """
config = Config.get() config = Config.get()
server = "" server = ""
if "digital_voice_codecserver" in config: if "digital_voice_codecserver" in config:
@ -593,72 +610,60 @@ class FeatureDetector(object):
def has_dump1090(self): def has_dump1090(self):
""" """
To be able to decode Mode-S and ADS-B traffic originating from airplanes, you need to install the dump1090 OpenWebRX supports decoding Mode-S and ADS-B airplane communications by using the
decoder. There is a number of forks available, any version that supports the `--ifile` and `--iformat` arguments [Dump1090](https://github.com/flightaware/dump1090) decoder. You can install the
should work. `dump1090-fa-minimal` package from the OpenWebRX repositories.
Recommended fork: [dump1090 by Flightaware](https://github.com/flightaware/dump1090) While there exist many Dump1090 forks, any version that supports `--ifile` and
`--iformat` arguments will work. We recommend using the
If you are using the OpenWebRX Debian or Ubuntu repository, you should be able to install the package [Dump1090 by FlightAware](https://github.com/flightaware/dump1090).
`dump1090-fa-minimal`. If you are using a different fork, please make sure that the `dump1090` command
(without suffixes) runs the desired version. You can use symbolic links or the
If you are running a different fork, please make sure that the command `dump1090` (without suffixes) runs the [Debian alternatives system](https://wiki.debian.org/DebianAlternatives) to
version you would like to use. You can use symbolic links or the achieve this.
[Debian alternatives system](https://wiki.debian.org/DebianAlternatives) to achieve this.
""" """
return self.command_is_runnable("dump1090 --version") return self.command_is_runnable("dump1090 --version")
def has_rtl_433(self): def has_rtl_433(self):
""" """
OpenWebRX can make use of the `rtl_433` software to decode various signals in the ISM bands. OpenWebRX supports decoding ISM signals from various sensors
by using the [RTL-433](https://github.com/merbanan/rtl_433)
You can find more information [here](https://github.com/merbanan/rtl_433). decoder suite. The `rtl-433` package is available in most Linux
distributions.
Debian and Ubuntu based systems should be able to install the package `rtl-433` from the package manager.
""" """
return self.command_is_runnable("rtl_433 -h") return self.command_is_runnable("rtl_433 -h")
def has_dumphfdl(self): def has_dumphfdl(self):
""" """
OpenWebRX supports decoding HFDL airplane communications using the `dumphfdl` decoder. OpenWebRX supports decoding HFDL airplane communications by using the
[DumpHFDL](https://github.com/szpajder/dumphfdl) decoder. You can
You can find more information [here](https://github.com/szpajder/dumphfdl) install the `dumphfdl` package from the OpenWebRX repositories.
If you are using the OpenWebRX Debian or Ubuntu repository, you should be able to install the package
`dumphfdl`.
""" """
return self.command_is_runnable("dumphfdl --version") return self.command_is_runnable("dumphfdl --version")
def has_dumpvdl2(self): def has_dumpvdl2(self):
""" """
OpenWebRX supports decoding VDL Mode 2 airplane communications using the `dumpvdl2` decoder. OpenWebRX supports decoding VDL Mode 2 airplane communications by using the
[DumpVDL2](https://github.com/szpajder/dumpvdl2) decoder. You can
You can find more information [here](https://github.com/szpajder/dumpvdl2) install the `dumpvdl2` package from the OpenWebRX repositories.
If you are using the OpenWebRX Debian or Ubuntu repository, you should be able to install the package
`dumpvdl2`.
""" """
return self.command_is_runnable("dumpvdl2 --version") return self.command_is_runnable("dumpvdl2 --version")
def has_redsea(self): def has_redsea(self):
""" """
OpenWebRX can decode RDS data on WFM broadcast station if the `redsea` decoder is available. OpenWebRX uses the [RedSea](https://github.com/windytan/redsea)
decoder to obtain the RDS information from WFM broadcasts. You can
You can find more information [here](https://github.com/windytan/redsea) install the `redsea` package from the OpenWebRX repositories.
If you are using the OpenWebRX Debian or Ubuntu repository, you should be able to install the package
`redsea`.
""" """
return self.command_is_runnable("redsea --version") return self.command_is_runnable("redsea --version")
def has_csdreti(self): def has_csdreti(self):
""" """
To decode DAB broadcast signals, OpenWebRX needs the ETI decoder from the To decode DAB broadcast signals, OpenWebRX needs the ETI decoder from the
[`csdr-eti`](https://github.com/jketterl/csdr-eti) project, together with the [`csdr-eti`](https://github.com/jketterl/csdr-eti) project, together with
associated python bindings from [`pycsdr-eti`](https://github.com/jketterl/pycsdr-eti). the associated Python bindings from [`pycsdr-eti`](https://github.com/jketterl/pycsdr-eti).
The `python3-csdr-eti` package, found in the OpenWebRX repositories,
If you are using the OpenWebRX Debian or Ubuntu repository, the `python3-csdr-eti` package should be all you should be all you need.
need.
""" """
required_version = LooseVersion("0.1") required_version = LooseVersion("0.1")
@ -675,10 +680,9 @@ class FeatureDetector(object):
def has_dablin(self): def has_dablin(self):
""" """
To decode DAB broadcast signals, OpenWebRX needs the [`dablin`](https://github.com/Opendigitalradio/dablin) OpenWebRX uses the [Dablin](https://github.com/Opendigitalradio/dablin)
decoding software. software to decode DAB broadcast signals. The `dablin` package is
available in most Linux distributions.
Dablin comes packaged with Debian and Ubuntu, so installing the `dablin` package should get you going.
""" """
return self.command_is_runnable("dablin -h") return self.command_is_runnable("dablin -h")