sdrangel

The idea is to pass samples through a delay line so that the exact squelch open and close times can be optimized to match the actual transmission. See here: https://brmlab.cz/user/jenda/kukuruku ("Squelch sucks").

Applied to NFM and AM demods. Most significant improvement is with the suppression of squelch noise tail in the NFM demod. This has been improved too in the SSB demod.

Applied to DSD demod also to help catch the very beginning of transmission regardless of gate time which is important for digital transmissions.

Merged contributions of jigpu (thanks!) to fix memory issues and spelling errors in documentation.

Now building with release 18.04.1 of LimeSuite that appears to fix the Tx problems. Also the Tx sample rate on the Mini can now go below 2.5 MS/s (tested at 1 MS/s). Unfortunately the Lime-Mini does not work in Windows since libusb and Zadig driver do not seem to work with the Mini. It is fine with the LimeSDR-USB though.

The transverter frequency translation has been implemented for both Rx and Tx thus implementing issue #155

Some plugins that are using the FFT filter were not deleting it at the right time thus in some cases some samples could still be processed through it after deletion. Sometimes it was not deleted at all thus creating a memory leak. This is now fixed and resolves issue #159

• UDP source and sink: make sure audio samples are always on 16 bits
• UDP source and sink: added dialog elements for address and port
• NFM demod: asymmetrical fade in and fade out for the squelch

Added support of source plugins:

• AirspyHF+
• BladeRF

Added support of sink plugins:

• BladeRF

Added support of channel Tx now covering the full list of plugins:

• AM modulator
• ATV modulator
• SSB modulator
• WFM modulator
• UDP sink

Fixed the segfault in RDS parser. Fixes issue #157

• NFM demodulator: fixed AF squelch and handling of audio sample rate
• PVS-Studio static analysis corrections (4th round)
• ScopeNG: reorganized Projector

• DSD demodulator plugin is compiled with DSDcc v 1.7.5 to support negative DMR
• A dialog to see the log of status messages has been added. This implements issue #135
• Set FM deviation independent from RF bandwidth as it depends on sample rate actually and this one is fixed at 48 kS/s

Fixed lowpass filter initialization to correct segfault when using CTCSS on both NFM demodulator and modulator

• Fixed graticule display flicker on ScopeXY screen
• BladeRF: added settings support in REST API
• Web API: scanner client example: added channel demod volume control

Complete redesign of the audio management with the possibility to set preferences by device in particular the sample rate. The audio device used for the audio stream of modulators and demodulators can be selected individually. This allows all sorts of audio plumbing between channel plugins and with external applications. Also by using sample rates as low as 8000 S/s it is possible to set the baseband sample rate below 48k (AM, NFM, SSB). The sending of a copy of the audio stream via UDP is handled at device level taking the audio mix. RTP protocol can be used over UDP for better connection to players that accept this format using SDP files. Consequently the UDP support at plugin level has been entirely removed. This implements issue #145

More details here: https://github.com/f4exb/sdrangel/blob/master/sdrgui/audio.md

• Fixes in ATV and DATV demods initialization
• Fixed stereo stream handling in RTP
• Extension to decimation by 64 for BladeRF and RTLSDR
• Extension to interpolation by 64 for HackRF

introduced a few fixes to work with LimeSuite version matching the 2.14 gateware i.e. commit https://github.com/myriadrf/LimeSuite/commit/90c39911b4a5f3db6488c8b1a199734a5db37a0e
Be careful not to use the latest commit for gateware 2.15 that has not been verified.

Now the Rx part is working with all its features. Unfortunately the Tx part still does not work (garbled modulation).

Fixes issue #139

New entry points to get the channel report data. Includes average power received and squelch status. A "scanner" Python script client scanner.py has been created in the swagger/sdrangel/examples folder. Check all options with python ./scanner.py --help. This script will create a series of equally spaced channel of the same type (AM or NFM) then the center frequency will sweep the requested band thus sweeping the channel "comb" over the requested band. As soon as one of the channel squelch is active the sweeping is stopped and resumes after a user defined delay. Some frequencies can be excluded so that it will not stop on continuous transmissions.

Support of AirspyHF source and AM demodulator added.
Partially implements issue #143

• RTLSDR direct mode frequency limits updated so that it starts at DC. Fixes issue #146
• MSVC/clang-cl export header fixes for swagger library
• Multiple audio support: preparatory works

🎉 New demodulator to decode DATV (Digital Amaeur TeleVision) signals. Many thanks to Laurent F4HKW for writing this plugin and Pascal F4DAV for LeanSDR that is at the heart of the demodulation and decoding process. For now only the DVB-S standard without audio is supported. More may come in the future and firstly the decoding of audio.

More information here: https://github.com/f4exb/sdrangel/tree/master/plugins/channelrx/demoddatv

Note that due to dependency with ffmpeg it is not possible to provide a Windows version at the moment.

The AM, NFM, SSB and WFM demodulators have now the option to send audio data over UDP using the RTP protocol by clicking on the "R" checkbox nest to the "U" button. Format is 48 kHz single channel with 16 bit signed samples. You may try to play this file saved with a .sdp extension with VLC:

c=IN IP4 127.0.0.1
m=audio 9998 RTP/AVP 96 
a=rtpmap:96 L16/48000/1

Replace IP address 127.0.0.1 and port 9998 by your values. Note that the port should be an even number.

The scope with all its controls has been removed in favor of a more simple "magic eye" display. Thus you are not obliged to go through the complex controls of the scope and can concentrate on bandwidth, FM deviation and gain to get the figure right for best decoding conditions.

More information here: https://github.com/f4exb/sdrangel/tree/master/plugins/channelrx/demoddsd

This release uses the latest version of LimeSuite that goes with the latest firmware on LimeSDR-USB and LimeSDR-Mini. Unfortunately many of the recent changes break the way things used to work and possibly some critical bugs have been introduced.

Therefore only single Rx is actually working. If you need anything else from your Lime please use the previous version of SDRangel and previous revisions of the firmware for the Lime.

• LimeSDR: show NCO and center frequency actual values
• Fixed channel demodulators and modulators initialization sequence that could solve segfaults when switching presets live. Also fixed the ordering of channel GUIs so that they are always ordered by increasing frequency.
• Added missing PlutoSDR output plugin in Windows distribution
• Code fixes to get clang-cl compile without warnings
• Reintroduced a clean way to handle exports for MSVC (clang-cl)
• More static analysis fixes

The Perseus is now supported in the Linux flavor only. If you compile from source you have to set the -DRX_SAMPLE_24BIT=ON flag on the cmake command line. This is to build with a 24 bit Rx DSP chain. The Perseus sends genuinely 24 bit samples so this is to match its sample size. More details here: https://github.com/f4exb/sdrangel/tree/master/plugins/samplesource/perseus

This implements #130 The I/Q correction was not working correctly since its origin missing the actual phase imbalance correction. This is now fixed with a more complete algorithm.

The following tools have been run against the code:

• Valgrind
• compilation with -fsanitize=address option
• static analysis tool thanks to a contributor: see #137

I hope this will make the code more robust and the application more stable. In addition some other issues were found and fixed and some dead code removed.

• Airspy HF support with the main airspyhf library
• Moving average cleanup
• LimeSDR interface with Lime Suite fixed to match newer version. Implements #133
• Adapted the SSB demod to the Perseus dynamic range
• Added AM and FM modulation to the Test Source
• Fixed the Qt5/cpp Swagger code generator so that it does not create memory leaks. Also implemented a lazy instantiation of objects. Consequently fixed memory leaks in the web API code.

The code for an internal RTP library and the DATV demodulator plugin are still a work in progress. The code compiles but cannot be considered as operational yet.

Note: the Windows build now comes in a single 32 bit flavor. Thus only the official Qt MinGW toolchain is used to build the release. An up to date toolchain with Qt 5.10.1 is used. 32 bit code can be used on 64 bit systems so this is not an issue. In addition it has the benefit of using Qt Angle which can help with systems without up to date OpenGL support.

Note2: the Linux builds are made with the 24 bit Rx DSP chain option.

Use option -DRX_SAMPLE_24BIT=ON on the cmake command line to build SDRangel with 24 bit wide samples for the Rx DSP processing. This is mostly useful for Airspy HF+ with decimation. Airspy HF+ has already 16 bit samples native so any decimation will not gain bit precision (hence dynamic range) when using 16 bit samples in the Rx DSP. However for sample rates over 1 MS/s the CPU load is increased by a small margin. Therefore this remains an option. The binary packages are still built with 16 bit Rx samples.

• UDP source: option to send 16 bit or 24 bit samples (on 32 bit integers)
• Web API: integrated Swagger UI alongside static HTML2 documentation

New source plugin to support Airspy HF+. See: https://github.com/f4exb/sdrangel/tree/master/plugins/samplesource/airspyhf If you compile this project you will need my copy of AirspyHF. See the readme for instructions.

Created a source plugin that generates a continuous wave for testing the software internals. See the plugin folder for details. This helped discover a few bugs in the decimation chain that are fixed in this version.

• RTL-SDR: implemented RF filter control (tuner bandwidth). This was available for some time in the librtlsdr library but was never implemented. For the lowest bandwidth values the filter seems a little bit offset on the higher frequencies but perfectly usable and indeed very useful.
• RTL-SDR and HackRF input: 8 bit samples shifting during decimation (RTL-SDR and HackRF Rx). For RTL-SDR also corrects the unsinged to signed 8 bit sample conversion.
• Airspy, BladeRF, HackRF, PlutoSDR, RTLSDR, SDRPlay: fix bug when changing to no decimation
• LimeSDR input: removed useless center frequency shift logic and related attributes and functions
• Show REST API URL in about dialog

Fixed segfault when stopping one device in multiple stream configuration. Was due to wrong initialization of shared data copying the other thread address as its own.

Refactor the rational decimator filtering. The cutoff was half of what it should be and was like this since quite a long time maybe since the creation of the plugin. In addition relaxed the filtering since the sharp filtering is done by a FFT filter. This can slightly increase performance.

• For all modulators and demodulators: apply initial channel settings at construction and start. This makes sure the proper initialization of channel NCO and interpolator/decimator is always done.
• File Source: fixed missing initialization of the do apply settings flag possibly preventing start.

This is mostly intended to power users.

Added possibility to launch processes from the GUI. This is set up and controlled from the commands view which details are described here This implements issue #49

Using the web REST API you can launch automated processes like the PTT (Push To Talk). In the swagger examples one can find the example of a PTT Python script. This is a working example however since the API does not cover all plugins yet this will work only with HackRF, LimeSDR or RTLSDR.

As an example in order to set this scenario up in the commands view you need to create a pair of commands one supporting the Rx to Tx and the other the Tx to Rx. You can create the first one then duplicate it and modify the copy.

To create the Rx to Tx:

• click on the "new" icon
• in the edit box fill the group and description for example:
  • PTT for the group
  • Transmit for the description
• locate the ptt.py script with the file dialog
• type in -a %1:%2 -d %3 -t for the arguments
• click on the "Key" button and type in the key you would like to use for PTT (ex: space bar)
• click on the checkbox at the left of the "Key" button
• confirm with OK

To create the Tx to Rx duplicate the first command and edit it:

• change the description to Receive for example
• for the arguments remove the -t: -a %1:%2 -d %3
• click on the release check box
• confirm with OK

To activate the newly created PTT key click on the button with the keyboard icon at the very right of buttons at the bottom of the commands tree view. Please note that if you do other actions in other windows in the meantime you may loose command control via keyboard in which case the keyboard button is released. You need to click it again to recover control.

The provided PTT script assumes that the Rx and Tx device sets (tabs) are next to each other (like R0 and T1) and that the Rx tab is active at the time the PTT is engaged for transmission.

This was tested successfully in a RTL-SDR (Rx) and HackRF (Tx) configuration. Please note that the ptt.py script will not work with LimeSDR Rx and Tx combination. With LimeSDR you should keep the Tx stream running and use the NFM modulator channel mute to stop transmission.

All commands with the same associated key are launched in parallel. This opens a new range of possibilities. For example you can combine the script that controls Rx/Tx in SDRangel with another one that handles PA control (you need to synchronize it with the Rx/Tx script as all scripts run in parallel). Then you don't need any physical connection between the Rx/Tx hardware and the PA. Everything would run in software. To launch commands in parallel you can also put all related commands in the same group and use the run button while the group is selected in the command tree view.

• AM, SSB demodulators and SSB modulator: fix sample rate handling. This solves issue #117
• Enhancements to presets processing and GUI
• Improved build and system info logging
• Web API: added function to set device set focus and get focused device set index in the instance summary (GUI only)

There was a long lasting problem where the multi threading in source channels was not effective while for Rx the channel sinks are really running concurrently. This fix should largely improve fluidity when using multiple or even a single source channel.

• Single channel: the device sink FIFO is directly connected to the source channel but signals are used for read and write so the device and channel threads can effectively run concurrently.
• Multiple channel: the device sink engine hosts the channel mixing process. It uses the channels FIFOs again relying on signals so the channels can run concurrently. Then the mixed signal is written to the device sink FIFO. This mixing process is inevitable and has no equivalent on the Rx side. Hence there could still be a performance hit on some systems. Therefore the warning message when adding more than one source is maintained. The situation should be significantly improved though.

You will need version 1.7.4 of dsdcc to support this with the default mbelib support. A Butterworth filter with -3 dB cutoff at 240 Hz is used instead of the Chebyshev with a -3 dB cutoff at 480 Hz used previously. Both are 2 pole IIR filters..

• Bug fixes on NFM, WFM modulators and UDP sink plugins that were introduced in previous revision
• Code fix on BFM demodulator that makes the compiler use less resources. This makes the BFM plugin compilable on a Rpi3 host.
• LimeSDR: use qDebug() differently so that it fixes a compilation issue on openSUSE builds with Qt 5.10

Implementation of a new binary sdrangelsrv that is similar to sdrangel but does not fire up a GUI. This server mode binary has therefore no dependency on Qt Widgets nor OpenGL. Since ot has no GUI its control is left entirely up to the web REST API interface.

It can serve two purposes:

• running headless on systems with lower CPU power than a laptop or desktop computer like the Raspberry Pi3. Thanks to the web API it can be remotely controlled also and thus can be at the heart of a complex multi mode transponder or repeater infrastructure.
• the web REST API can be used in a client-server configuration with the client implementing a custom and possibly simplified GUI. In this configuration the standard GUI becomes useless and can be removed to save CPU.

This is a proof of concept at this stage with only a subset of plugins available:

• For the sampling devices: RTLSDR, HackRF (in/out), LimeSDR (in/out)
• For the channel plugins: NFM modulator and demodulator

This is distributed only in Linux packages.

Implemented an optional high-pass filter on audio so that voice readability can be improved in some cases. Please note that this makes use of the version v1.7.3 of DSDcc thus this release (or later) must be used if you want to compile the DSD demodulator plugin.

• The return of the Windows 32 bit release: it appears that the toolchain building the 64 bit version misses Qt ANGLE support. Without ANGLE OpenGL is used directly and thus the default OpenGL 1.1 used in some sytems cannot work. This mostly explains why SDRangel will not start on some Windows systems. In particular this is the case with a Virtualbox Windows guest. Conversely the 32 bit toolchain does have support for ANGLE and thus can make use of the OpenGL emulation based on Direct-X that can work when only the default OpenGL 1.1 is available. The 32 bit version misses some plugins but can still be useful. It can also run on 64 bit systems.
• Fixed ATV modulator plugin in Windows 64 bit distribution (not available in 32 bit)
• Binary distribution files of only the 5 last versions will be kept to save space.

• Down/Up channelizers: enqeue MsgChannelizerNotification to sample sink/source instead of processing it directly. Can improve stability and preset not loading correctly in some cases.
• Use specific method to apply channelizer sample rate and frequency offset changes. Separate this data from settings. Can improve stability and preset not loading correctly in some cases.
• LimeSDR: apply settings with force on construction
• LimeSDR: changed udev rules to give all access to device
• Some web API fixes and adjustments
• Plugin interface: simplifications in channel creation
• Device plugins: make setMessageQueueToGUI pure virtual so that child classes must have to deal with this
• gcc7 warnings fixes that can improve code quality
• cppcheck fixes that can improve code quality

Binary releases are compiled with the latest version of LimeSuite (commit 04b57e0) to fix segfault when using only the second channel or starting the second channel first.

• /sdrangel/deviceset/{deviceSetIndex}/device/run POST,DELETE to start/stop a device implemented for all source and sink plugins
• added more client examples in a dedicated folder and added a readme: https://github.com/f4exb/sdrangel/tree/master/swagger/sdrangel/examples
• use message passing to start/stop device
• /sdrangel/deviceset/{deviceSetIndex}/channel/{channelIndex}/settings PUT, PATCH for NFM demod and mod

• added test in main CmakeLists.txt file to abort build if gcc version is lower than 4.9. Older versions cannot compile std::regex correctly.

• LimeSDR: fixed analog LP setting

• Scale to show LSB/USB filters sliders position.
• Button to flip LSB to USB or vice versa

This helps support LimeSDR mini correctly in particular the change of Rx and Tx path routing according to antenna switch (issue #100)

• Option to copy audio to UDP for SSB demod and WFM demod.

Main window can be controlled almost completely with the web API. A complete configuration can be set up using a script. For example the following Python script does the following:

• select BladeRF for the first Rx
• load a preset for the first Rx
• create a new device set (Rx tab)
• select SDRdaemonSource for the second Rx
• load a preset for the second Rx
• create a new device set (Rx tab)
• select SDRplay for the third Rx
• load a preset for the third Rx
• activate DV serial dongle support

import requests

base_url = "http://127.0.0.1:8091/sdrangel"

# commands list. Each command is a list:
#   - URL suffix (API function)
#   - HTTP method (GET, PATCH, POST, PUT, DELETE)
#   - Params as key:value pairs or None if unused
#   - JSON body or None if unused
#   - Descriptive message fragment
commands = [
    ["/deviceset/0/device", "PUT", None, {"hwType": "BladeRF"}, "setup BladeRF on Rx 0"],
    ["/preset", "PATCH", None, {"deviceSetIndex": 0, "preset": {"groupName": "OM144", "centerFrequency": 145640000, "type": "R", "name": "Repeaters extended"}}, "load preset on Rx 0"],
    ["/devicesets", "POST", None, None, "add Rx 1 device set"],
    ["/deviceset/1/device", "PUT", None, {"hwType": "SDRdaemonSource"}, "setup SDRdaemonSource on Rx 1"],
    ["/preset", "PATCH", None, {"deviceSetIndex": 1, "preset": {"groupName": "OM430", "centerFrequency": 439550000, "type": "R", "name": "F5ZKP Daemon RPi3 SUSE"}}, "load preset on Rx 1"],
    ["/devicesets", "POST", None, None, "add Rx 2 device set"],
    ["/deviceset/2/device", "PUT", None, {"hwType": "SDRplay1"}, "setup SDRplay on Rx 2"],
    ["/preset", "PATCH", None, {"deviceSetIndex": 2, "preset": {"groupName": "40m", "centerFrequency": 7130000, "type": "R", "name": "SSB low"}}, "load preset on Rx 2"],
    ["/dvserial", "PATCH", {"dvserial": 1}, None, "set DV serial processing for AMBE frames decoding"]
]

requests_methods = {
    "GET": requests.get,
    "PATCH": requests.patch,
    "POST": requests.post,
    "PUT": requests.put,
    "DELETE": requests.delete
}

for command in commands:
    url = base_url + command[0]
    method = requests_methods.get(command[1], None)
    if method is not None:
        r = method(url=url, params=command[2], json=command[3])
        if r.status_code == 200:
            print("Done: %s" % command[4])
        else:
            print("Error %d:%s" % (r.status_code, command[4]))
            print(r.text)
            exit(1)
    else:
        print("requests method error")
        exit(1)

print("All done!")

• Value dials direct digit input fixes. Fixes issue #97
• Channel analyzers: fixed delta frequency change
• Fixed cmake file of internal librtlsdr since upgrade to 0.7.0+

• Channel marker event handlig: have two distinct events for change of channel marker by methods and by action on the cursor in the spectrum view. This makes a more rational event handling in channel plugins and avoids extra configuration messages. This may improve experience with the GUI.
• Highlight channel plugin window frame when the channel marker is moused over in the main spectrum view
• SSB mod and demod GUIs: added a schematic frequency scale and align low pass and high pass filters sliders.

Used Swagger to design the web API. You can sneak peek in the generated documentation in HTML by browsing swagger/sdrangel/code/html2/index.html directly with a browser in your cloned repository. Only the client code is generated for Qt5 but the data structures can be re-used for the server.

At the moment only the information summary /sdrangel path is implemented. The default host and port at startup is 127.0.0.1:8091 this can be changed with the -a (host address) and -p (port) options given as arguments to the sdrangel binary.

Thanks to the Stefan Frings' QtWebApp logging package which was modified to fit SDRangel needs a more professional looking logging has been put in place. Included is the option to log messages to a file along with the console. This is particularly interesting when running in Windows where no console message are displayed. Thus it is now possible to visualize debug messages in Windows.

A new dialog opens from Preferences > Logging menu in the main window to control settings. See details here: https://github.com/f4exb/sdrangel/tree/master/sdrgui#12-logging-preferences

Note: in order to be able to see debug messages the Ubuntu and Debian builds are set with debug messages ON at compilation time. The minimum message level to be logged is "debug" by default but can be adjusted in the logging preference dialog. This setting is persistent in the presets and current preset.

• SSB mod/demod: make sure channel marker bandwidth and low cutoff are displayed correctly
• Channel analyzer NG: fixed GUI displays (mainly spectrum) when channel sample rate changes. Some code cleanup
• LimeSDR: increased start/stop stream wait time to 50ms to fixed possible stability issues when changes are applied
• BFM demod: fixed spectrum gui update when channel sample rate changes
• Some code cleanup

Fixed a segfault and/or infinite loop by re-organizing constructor instructions sequence. This fixes issue #88

• LimeSDR: fixed analog LP bandwidth filter and general calibration. According to LMS7002M Wiki: https://wiki.myriadrf.org/LMS7002Mr3_Calibration_Using_MCU the calibration was not done quite right. See details in issue #92. This version corrects this and is supposed to be done right
• ATV modulator: fixed text overlay size

GUI and Rx/Tx channel core separation: modulator/demodulator constructor separated from the modulator.demodulator GUI constructor.

Added a dialog to LimeSDR plugins to be able to switch the clock reference to the external clock input. See here for detals.

• Input: https://github.com/f4exb/sdrangel/tree/master/plugins/samplesource/limesdrinput#2-nco-dciq-correction-and-external-clock-controls
• Output: https://github.com/f4exb/sdrangel/blob/master/plugins/samplesink/limesdroutput/readme.md#7a-external-clock-control

This implements issue #74

Fixed issues with SSB modulator GUI when fiddling with SSB/DSB or the bandwidth sliders. This fixes issue #87

Use the current locale to set the group delimiter on the value dials (separator between thousands). This used to be a dot (".") which is the case in many countries but the US and the UK where a comma is used. Anyway most hams and professionals alike are used the the US/UK notation so as the binaries are built on machines with US locale the separator will be a comma. If you compile from source it will be the separator used in your locale.