From 37521224c366dddeb4256d99c37263693e8e5f6f Mon Sep 17 00:00:00 2001
From: srcejon <jon@beniston.com>
Date: Thu, 28 Sep 2023 16:45:35 +0100
Subject: [PATCH 01/23] Add frequency scanner channel plugin

---
 CMakeLists.txt                                |    1 +
 plugins/channelrx/freqscanner/CMakeLists.txt  |   66 ++
 plugins/channelrx/freqscanner/freqscanner.cpp | 1036 +++++++++++++++++
 plugins/channelrx/freqscanner/freqscanner.h   |  435 +++++++
 .../freqscanner/freqscanneraddrangedialog.cpp |   48 +
 .../freqscanner/freqscanneraddrangedialog.h   |   44 +
 .../freqscanner/freqscanneraddrangedialog.ui  |  222 ++++
 .../freqscanner/freqscannerbaseband.cpp       |  215 ++++
 .../freqscanner/freqscannerbaseband.h         |  102 ++
 .../channelrx/freqscanner/freqscannergui.cpp  |  911 +++++++++++++++
 .../channelrx/freqscanner/freqscannergui.h    |  142 +++
 .../channelrx/freqscanner/freqscannergui.ui   |  776 ++++++++++++
 .../freqscanner/freqscannerplugin.cpp         |   93 ++
 .../channelrx/freqscanner/freqscannerplugin.h |   50 +
 .../freqscanner/freqscannersettings.cpp       |  366 ++++++
 .../freqscanner/freqscannersettings.h         |   96 ++
 .../channelrx/freqscanner/freqscannersink.cpp |  253 ++++
 .../channelrx/freqscanner/freqscannersink.h   |   86 ++
 .../freqscanner/freqscannerwebapiadapter.cpp  |   52 +
 .../freqscanner/freqscannerwebapiadapter.h    |   50 +
 plugins/channelrx/freqscanner/readme.md       |  121 ++
 sdrbase/channel/channelwebapiutils.cpp        |   41 +
 sdrbase/channel/channelwebapiutils.h          |    1 +
 sdrbase/webapi/webapirequestmapper.cpp        |    9 +
 sdrbase/webapi/webapiutils.cpp                |    2 +
 sdrgui/gui/frequencydelegate.cpp              |  110 +-
 sdrgui/gui/frequencydelegate.h                |   10 +-
 .../api/swagger/include/ChannelReport.yaml    |    2 +
 .../api/swagger/include/ChannelSettings.yaml  |    2 +
 .../api/swagger/include/FreqScanner.yaml      |   70 ++
 30 files changed, 5395 insertions(+), 17 deletions(-)
 create mode 100644 plugins/channelrx/freqscanner/CMakeLists.txt
 create mode 100644 plugins/channelrx/freqscanner/freqscanner.cpp
 create mode 100644 plugins/channelrx/freqscanner/freqscanner.h
 create mode 100644 plugins/channelrx/freqscanner/freqscanneraddrangedialog.cpp
 create mode 100644 plugins/channelrx/freqscanner/freqscanneraddrangedialog.h
 create mode 100644 plugins/channelrx/freqscanner/freqscanneraddrangedialog.ui
 create mode 100644 plugins/channelrx/freqscanner/freqscannerbaseband.cpp
 create mode 100644 plugins/channelrx/freqscanner/freqscannerbaseband.h
 create mode 100644 plugins/channelrx/freqscanner/freqscannergui.cpp
 create mode 100644 plugins/channelrx/freqscanner/freqscannergui.h
 create mode 100644 plugins/channelrx/freqscanner/freqscannergui.ui
 create mode 100644 plugins/channelrx/freqscanner/freqscannerplugin.cpp
 create mode 100644 plugins/channelrx/freqscanner/freqscannerplugin.h
 create mode 100644 plugins/channelrx/freqscanner/freqscannersettings.cpp
 create mode 100644 plugins/channelrx/freqscanner/freqscannersettings.h
 create mode 100644 plugins/channelrx/freqscanner/freqscannersink.cpp
 create mode 100644 plugins/channelrx/freqscanner/freqscannersink.h
 create mode 100644 plugins/channelrx/freqscanner/freqscannerwebapiadapter.cpp
 create mode 100644 plugins/channelrx/freqscanner/freqscannerwebapiadapter.h
 create mode 100644 plugins/channelrx/freqscanner/readme.md
 create mode 100644 swagger/sdrangel/api/swagger/include/FreqScanner.yaml

diff --git a/CMakeLists.txt b/CMakeLists.txt
index e6cf4cea8..f300ba8ec 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -92,6 +92,7 @@ option(ENABLE_CHANNELRX_DEMODRTTY "Enable channelrx demodrtty plugin" ON)
 option(ENABLE_CHANNELRX_DEMODILS "Enable channelrx demodils plugin" ON)
 option(ENABLE_CHANNELRX_DEMODDSC "Enable channelrx demoddsc plugin" ON)
 option(ENABLE_CHANNELRX_HEATMAP "Enable channelrx heatmap plugin" ON)
+option(ENABLE_CHANNELRX_FREQSCANNER "Enable channelrx freqscanner plugin" ON)
 
 # Channel Tx enablers
 option(ENABLE_CHANNELTX "Enable channeltx plugins" ON)
diff --git a/plugins/channelrx/freqscanner/CMakeLists.txt b/plugins/channelrx/freqscanner/CMakeLists.txt
new file mode 100644
index 000000000..b02ad52b0
--- /dev/null
+++ b/plugins/channelrx/freqscanner/CMakeLists.txt
@@ -0,0 +1,66 @@
+project(freqscanner)
+
+set(freqscanner_SOURCES
+    freqscanner.cpp
+    freqscannersettings.cpp
+    freqscannerbaseband.cpp
+    freqscannersink.cpp
+    freqscannerplugin.cpp
+    freqscannerwebapiadapter.cpp
+)
+
+set(freqscanner_HEADERS
+    freqscanner.h
+    freqscannersettings.h
+    freqscannerbaseband.h
+    freqscannersink.h
+    freqscannerplugin.h
+    freqscannerwebapiadapter.h
+)
+
+include_directories(
+    ${CMAKE_SOURCE_DIR}/swagger/sdrangel/code/qt5/client
+)
+
+if(NOT SERVER_MODE)
+    set(freqscanner_SOURCES
+        ${freqscanner_SOURCES}
+        freqscannergui.cpp
+        freqscannergui.ui
+        freqscanneraddrangedialog.cpp
+        freqscanneraddrangedialog.ui
+    )
+    set(freqscanner_HEADERS
+        ${freqscanner_HEADERS}
+        freqscannergui.h
+        freqscanneraddrangedialog.h
+    )
+
+    set(TARGET_NAME freqscanner)
+    set(TARGET_LIB "Qt::Widgets")
+    set(TARGET_LIB_GUI "sdrgui")
+    set(INSTALL_FOLDER ${INSTALL_PLUGINS_DIR})
+else()
+    set(TARGET_NAME freqscannersrv)
+    set(TARGET_LIB "")
+    set(TARGET_LIB_GUI "")
+    set(INSTALL_FOLDER ${INSTALL_PLUGINSSRV_DIR})
+endif()
+
+add_library(${TARGET_NAME} SHARED
+    ${freqscanner_SOURCES}
+)
+
+target_link_libraries(${TARGET_NAME}
+    Qt::Core
+    ${TARGET_LIB}
+    sdrbase
+    ${TARGET_LIB_GUI}
+)
+
+install(TARGETS ${TARGET_NAME} DESTINATION ${INSTALL_FOLDER})
+
+# Install debug symbols
+if (WIN32)
+    install(FILES $<TARGET_PDB_FILE:${TARGET_NAME}> CONFIGURATIONS Debug RelWithDebInfo DESTINATION ${INSTALL_FOLDER} )
+endif()
diff --git a/plugins/channelrx/freqscanner/freqscanner.cpp b/plugins/channelrx/freqscanner/freqscanner.cpp
new file mode 100644
index 000000000..904a94111
--- /dev/null
+++ b/plugins/channelrx/freqscanner/freqscanner.cpp
@@ -0,0 +1,1036 @@
+///////////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2015-2018 Edouard Griffiths, F4EXB.                             //
+// Copyright (C) 2023 Jon Beniston, M7RCE                                        //
+//                                                                               //
+// This program is free software; you can redistribute it and/or modify          //
+// it under the terms of the GNU General Public License as published by          //
+// the Free Software Foundation as version 3 of the License, or                  //
+// (at your option) any later version.                                           //
+//                                                                               //
+// This program is distributed in the hope that it will be useful,               //
+// but WITHOUT ANY WARRANTY; without even the implied warranty of                //
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                  //
+// GNU General Public License V3 for more details.                               //
+//                                                                               //
+// You should have received a copy of the GNU General Public License             //
+// along with this program. If not, see <http://www.gnu.org/licenses/>.          //
+///////////////////////////////////////////////////////////////////////////////////
+
+#include "freqscanner.h"
+
+#include <QTime>
+#include <QDebug>
+#include <QNetworkAccessManager>
+#include <QNetworkReply>
+#include <QBuffer>
+#include <QThread>
+
+#include <stdio.h>
+#include <complex.h>
+
+#include "SWGChannelSettings.h"
+#include "SWGWorkspaceInfo.h"
+//#include "SWGFreqScannerSettings.h"
+#include "SWGChannelReport.h"
+#include "SWGMapItem.h"
+
+#include "device/deviceset.h"
+#include "dsp/dspengine.h"
+#include "dsp/dspcommands.h"
+#include "dsp/morsedemod.h"
+#include "device/deviceapi.h"
+#include "feature/feature.h"
+#include "settings/serializable.h"
+#include "util/db.h"
+#include "channel/channelwebapiutils.h"
+#include "maincore.h"
+
+MESSAGE_CLASS_DEFINITION(FreqScanner::MsgConfigureFreqScanner, Message)
+MESSAGE_CLASS_DEFINITION(FreqScanner::MsgReportChannels, Message)
+MESSAGE_CLASS_DEFINITION(FreqScanner::MsgStartScan, Message)
+MESSAGE_CLASS_DEFINITION(FreqScanner::MsgStopScan, Message)
+MESSAGE_CLASS_DEFINITION(FreqScanner::MsgScanComplete, Message)
+MESSAGE_CLASS_DEFINITION(FreqScanner::MsgScanResult, Message)
+MESSAGE_CLASS_DEFINITION(FreqScanner::MsgStatus, Message)
+MESSAGE_CLASS_DEFINITION(FreqScanner::MsgReportActiveFrequency, Message)
+MESSAGE_CLASS_DEFINITION(FreqScanner::MsgReportActivePower, Message)
+MESSAGE_CLASS_DEFINITION(FreqScanner::MsgReportScanning, Message)
+MESSAGE_CLASS_DEFINITION(FreqScanner::MsgReportScanRange, Message)
+
+const char * const FreqScanner::m_channelIdURI = "sdrangel.channel.freqscanner";
+const char * const FreqScanner::m_channelId = "FreqScanner";
+
+FreqScanner::FreqScanner(DeviceAPI *deviceAPI) :
+        ChannelAPI(m_channelIdURI, ChannelAPI::StreamSingleSink),
+        m_deviceAPI(deviceAPI),
+        m_running(false),
+        m_basebandSampleRate(0),
+        m_scanDeviceSetIndex(-1),
+        m_scanChannelIndex(-1),
+        m_state(IDLE),
+        m_timeoutTimer(this)
+{
+    setObjectName(m_channelId);
+
+    m_basebandSink = new FreqScannerBaseband(this);
+    m_basebandSink->setMessageQueueToChannel(getInputMessageQueue());
+    m_basebandSink->setChannel(this);
+    m_basebandSink->moveToThread(&m_thread);
+
+    applySettings(m_settings, QStringList(), true);
+
+    m_deviceAPI->addChannelSink(this);
+    m_deviceAPI->addChannelSinkAPI(this);
+
+    m_networkManager = new QNetworkAccessManager();
+    QObject::connect(
+        m_networkManager,
+        &QNetworkAccessManager::finished,
+        this,
+        &FreqScanner::networkManagerFinished
+    );
+    QObject::connect(
+        this,
+        &ChannelAPI::indexInDeviceSetChanged,
+        this,
+        &FreqScanner::handleIndexInDeviceSetChanged
+    );
+
+    scanAvailableChannels();
+    QObject::connect(
+        MainCore::instance(),
+        &MainCore::channelAdded,
+        this,
+        &FreqScanner::handleChannelAdded
+    );
+    QObject::connect(
+        MainCore::instance(),
+        &MainCore::channelRemoved,
+        this,
+        &FreqScanner::handleChannelRemoved
+    );
+
+    m_timeoutTimer.callOnTimeout(this, &FreqScanner::timeout);
+}
+
+FreqScanner::~FreqScanner()
+{
+    qDebug("FreqScanner::~FreqScanner");
+    QObject::disconnect(
+        m_networkManager,
+        &QNetworkAccessManager::finished,
+        this,
+        &FreqScanner::networkManagerFinished
+    );
+    delete m_networkManager;
+    m_deviceAPI->removeChannelSinkAPI(this);
+    m_deviceAPI->removeChannelSink(this);
+
+    if (m_basebandSink->isRunning()) {
+        stop();
+    }
+
+    delete m_basebandSink;
+}
+
+void FreqScanner::setDeviceAPI(DeviceAPI *deviceAPI)
+{
+    if (deviceAPI != m_deviceAPI)
+    {
+        m_deviceAPI->removeChannelSinkAPI(this);
+        m_deviceAPI->removeChannelSink(this);
+        m_deviceAPI = deviceAPI;
+        m_deviceAPI->addChannelSink(this);
+        m_deviceAPI->addChannelSinkAPI(this);
+    }
+}
+
+uint32_t FreqScanner::getNumberOfDeviceStreams() const
+{
+    return m_deviceAPI->getNbSourceStreams();
+}
+
+void FreqScanner::feed(const SampleVector::const_iterator& begin, const SampleVector::const_iterator& end, bool firstOfBurst)
+{
+    (void) firstOfBurst;
+
+    if (m_running) {
+        m_basebandSink->feed(begin, end);
+    }
+}
+
+void FreqScanner::start()
+{
+    if (m_running) {
+        return;
+    }
+
+    qDebug("FreqScanner::start");
+
+    m_basebandSink->reset();
+    m_basebandSink->startWork();
+    m_thread.start();
+    // FIXME: Threading!! Compare to SSB
+
+    DSPSignalNotification *dspMsg = new DSPSignalNotification(m_basebandSampleRate, m_centerFrequency);
+    m_basebandSink->getInputMessageQueue()->push(dspMsg);
+
+    FreqScannerBaseband::MsgConfigureFreqScannerBaseband *msg = FreqScannerBaseband::MsgConfigureFreqScannerBaseband::create(m_settings, QStringList(), true);
+    m_basebandSink->getInputMessageQueue()->push(msg);
+
+    m_running = true;
+}
+
+void FreqScanner::stop()
+{
+    if (!m_running) {
+        return;
+    }
+
+    qDebug("FreqScanner::stop");
+    m_running = false;
+    m_basebandSink->stopWork();
+    m_thread.quit();
+    m_thread.wait();
+}
+
+bool FreqScanner::handleMessage(const Message& cmd)
+{
+    if (MsgConfigureFreqScanner::match(cmd))
+    {
+        MsgConfigureFreqScanner& cfg = (MsgConfigureFreqScanner&) cmd;
+        qDebug() << "FreqScanner::handleMessage: MsgConfigureFreqScanner";
+        applySettings(cfg.getSettings(), cfg.getSettingsKeys(), cfg.getForce());
+
+        return true;
+    }
+    else if (DSPSignalNotification::match(cmd))
+    {
+        DSPSignalNotification& notif = (DSPSignalNotification&) cmd;
+        m_basebandSampleRate = notif.getSampleRate();
+        m_centerFrequency = notif.getCenterFrequency();
+        qDebug() << "FreqScanner::handleMessage: DSPSignalNotification";
+        // Forward to the sink
+        if (m_running)
+        {
+            DSPSignalNotification* rep = new DSPSignalNotification(notif); // make a copy
+            m_basebandSink->getInputMessageQueue()->push(rep);
+        }
+        // Forward to GUI if any
+        if (m_guiMessageQueue) {
+            m_guiMessageQueue->push(new DSPSignalNotification(notif));
+        }
+
+        return true;
+    }
+    else if (MsgStartScan::match(cmd))
+    {
+        qInfo() << "FreqScanner::handleMessage: StartScan";
+
+        startScan();
+
+        return true;
+    }
+    else if (MsgStopScan::match(cmd))
+    {
+        qInfo() << "FreqScanner::handleMessage: StopScan";
+
+        stopScan();
+
+        return true;
+    }
+    else if (MsgScanResult::match(cmd))
+    {
+        MsgScanResult& result = (MsgScanResult&)cmd;
+        const QList<MsgScanResult::ScanResult>& results = result.getScanResults();
+
+        processScanResults(result.getFFTStartTime(), results);
+
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+void FreqScanner::startScan()
+{
+    // Start scan
+    m_state = START_SCAN;
+}
+
+void FreqScanner::stopScan()
+{
+    // Stop scan
+    m_state = IDLE;
+    m_timeoutTimer.stop();
+
+    if (m_guiMessageQueue) {
+        m_guiMessageQueue->push(MsgStatus::create(""));
+    }
+}
+
+void FreqScanner::initScan()
+{
+    ChannelWebAPIUtils::setAudioMute(m_scanDeviceSetIndex, m_scanChannelIndex, true);
+
+    if (m_centerFrequency != m_stepStartFrequency)
+    {
+        qInfo() << "******************** Setting frequency to " << m_stepStartFrequency;
+        if (!ChannelWebAPIUtils::setCenterFrequency(getDeviceSetIndex(), m_stepStartFrequency)) {
+            qWarning() << "Scanner failed to set frequency" << m_stepStartFrequency;
+        }
+        m_minFFTStartTime = QDateTime::currentDateTime().addMSecs(m_settings.m_tuneTime);
+        qInfo() << "m_minFFTStartTime" << m_minFFTStartTime.toString("ss.z");
+    }
+
+    qDebug() << "********* initScan: Clear results";
+    m_scanResults.clear();
+    qDebug() << "********* initScan: Clear results done";
+
+    if (m_guiMessageQueue) {
+        m_guiMessageQueue->push(FreqScanner::MsgReportScanning::create());
+    }
+
+    m_state = SCAN_FOR_MAX_POWER;
+}
+
+void FreqScanner::processScanResults(const QDateTime& fftStartTime, const QList<MsgScanResult::ScanResult>& results)
+{
+
+    switch (m_state)
+    {
+
+    case START_SCAN:
+        {
+            // Create ordered list of frequencies to scan
+            QList<qint64> frequencies;
+            for (int i = 0; i < m_settings.m_frequencies.size(); i++)
+            {
+                if (m_settings.m_enabled[i]) {
+                    frequencies.append(m_settings.m_frequencies[i]);
+                }
+            }
+            qSort(frequencies);
+
+            // Calculate how many channels can be scanned in one go
+            int fftSize;
+            int binsPerChannel;
+            FreqScanner::calcScannerSampleRate(m_settings.m_channelBandwidth, m_basebandSampleRate, m_scannerSampleRate, fftSize, binsPerChannel);
+
+            // Align first frequency so we cover as many channels as possible, while avoiding DC bin
+            m_stepStartFrequency = frequencies.front() + m_scannerSampleRate / 2 - m_settings.m_channelBandwidth + m_settings.m_channelBandwidth / 2;
+            m_stepStopFrequency = frequencies.back();
+
+            qInfo() << "START_SCAN: Scanning from " << frequencies.front() << "to" << frequencies.back();
+            initScan();
+        }
+        break;
+
+    case SCAN_FOR_MAX_POWER:
+        if (fftStartTime >= m_minFFTStartTime)
+        {
+            if (results.size() > 0) {
+                m_scanResults.append(results);
+            }
+
+            bool complete = false; // Have all frequencies been scanned?
+            qint64 nextCenterFrequency = m_centerFrequency;
+
+            if (m_stepStopFrequency < m_centerFrequency + m_scannerSampleRate / 2)
+            {
+                nextCenterFrequency = m_stepStartFrequency;
+                complete = true;
+            }
+            else
+            {
+                nextCenterFrequency = m_centerFrequency + m_scannerSampleRate;
+                complete = false;
+            }
+
+            if (complete)
+            {
+                if (m_scanResults.size() > 0)
+                {
+                    // Send scan results to GUI for display in table
+                    if (m_guiMessageQueue)
+                    {
+                        FreqScanner::MsgScanResult* msg = FreqScanner::MsgScanResult::create(QDateTime());
+                        QList<FreqScanner::MsgScanResult::ScanResult>& guiResults = msg->getScanResults();
+                        guiResults.append(m_scanResults);
+                        m_guiMessageQueue->push(msg);
+                    }
+
+                    int frequency = m_scanResults[0].m_frequency;
+                    Real maxPower = m_scanResults[0].m_power;
+
+                    if (m_settings.m_priority == FreqScannerSettings::MAX_POWER)
+                    {
+                        // Find frequency with max power
+                        for (int i = 1; i < m_scanResults.size(); i++)
+                        {
+                            if (m_scanResults[i].m_power > maxPower)
+                            {
+                                frequency = m_scanResults[i].m_frequency;
+                                maxPower = m_scanResults[i].m_power;
+                            }
+                        }
+                    }
+                    else
+                    {
+                        // Find first frequency in list above threshold
+                        for (int j = 0; j < m_settings.m_frequencies.size(); j++)
+                        {
+                            for (int i = 0; i < m_scanResults.size(); i++)
+                            {
+                                if (m_scanResults[i].m_frequency == m_settings.m_frequencies[j])
+                                {
+                                    if (m_scanResults[i].m_power >= m_settings.m_threshold)
+                                    {
+                                        frequency = m_scanResults[i].m_frequency;
+                                        maxPower = m_scanResults[i].m_power;
+                                        goto found_freq;
+                                    }
+                                }
+                            }
+                        }
+                        found_freq: ;
+                    }
+
+                    if (m_settings.m_mode != FreqScannerSettings::SCAN_ONLY)
+                    {
+                        // Is power above threshold
+                        if (maxPower >= m_settings.m_threshold)
+                        {
+                            if (m_guiMessageQueue) {
+                                m_guiMessageQueue->push(MsgReportActiveFrequency::create(frequency));
+                            }
+
+                            // Tune device/channel to frequency
+                            int offset;
+                            if ((frequency < m_centerFrequency - m_scannerSampleRate / 2) || (frequency >= m_centerFrequency + m_scannerSampleRate / 2))
+                            {
+                                nextCenterFrequency = frequency;
+                                offset = 0;
+                            }
+                            else
+                            {
+                                nextCenterFrequency = m_centerFrequency;
+                                offset = frequency - m_centerFrequency;
+                            }
+
+                            // Ensure we have minimum offset from DC
+                            if (offset >= 0)
+                            {
+                                while (offset < m_settings.m_channelFrequencyOffset)
+                                {
+                                    nextCenterFrequency -= m_settings.m_channelBandwidth;
+                                    offset += m_settings.m_channelBandwidth;
+                                }
+                            }
+                            else
+                            {
+                                while (abs(offset) < m_settings.m_channelFrequencyOffset)
+                                {
+                                    nextCenterFrequency += m_settings.m_channelBandwidth;
+                                    offset -= m_settings.m_channelBandwidth;
+                                }
+                            }
+
+                            //qInfo() << "Tuning to active freq:" << frequency << "m_centerFrequency" << m_centerFrequency << "nextCenterFrequency" << nextCenterFrequency << "offset: " << offset << "deviceset: R" << m_scanDeviceSetIndex << ":" << m_scanChannelIndex;
+
+                            ChannelWebAPIUtils::setFrequencyOffset(m_scanDeviceSetIndex, m_scanChannelIndex, offset);
+
+                            // Unmute the channel
+                            ChannelWebAPIUtils::setAudioMute(m_scanDeviceSetIndex, m_scanChannelIndex, false);
+
+                            m_activeFrequency = frequency;
+
+                            if (m_settings.m_mode == FreqScannerSettings::SINGLE)
+                            {
+                                // Scan complete
+                                if (m_guiMessageQueue) {
+                                    m_guiMessageQueue->push(MsgScanComplete::create());
+                                }
+                                m_state = IDLE;
+                            }
+                            else
+                            {
+                                // Wait for transmission to finish
+                                m_state = WAIT_FOR_END_TX;
+                            }
+                        }
+                        else
+                        {
+                            if (m_guiMessageQueue) {
+                                m_guiMessageQueue->push(MsgStatus::create(QString("Scanning: No active channels - Max power %1 dB").arg(maxPower)));
+                            }
+                        }
+                    }
+                }
+            }
+
+            if (nextCenterFrequency != m_centerFrequency)
+            {
+                // For RTL SDR, setCenterFrequency takes ~50ms, which means tuneTime can be 0
+                if (!ChannelWebAPIUtils::setCenterFrequency(getDeviceSetIndex(), nextCenterFrequency)) {
+                    qWarning() << "Scanner failed to set frequency" << nextCenterFrequency;
+                }
+                m_minFFTStartTime = QDateTime::currentDateTime().addMSecs(m_settings.m_tuneTime);
+            }
+
+            if (complete) {
+                m_scanResults.clear();
+            }
+        }
+        break;
+
+    case WAIT_FOR_END_TX:
+        for (int i = 0; i < results.size(); i++)
+        {
+            if (results[i].m_frequency == m_activeFrequency)
+            {
+                if (m_guiMessageQueue) {
+                    m_guiMessageQueue->push(MsgReportActivePower::create(results[i].m_power));
+                }
+
+                // Wait until power drops below threshold
+                if (results[i].m_power < m_settings.m_threshold)
+                {
+                    m_timeoutTimer.setSingleShot(true);
+                    m_timeoutTimer.start((int)(m_settings.m_retransmitTime * 1000.0));
+                    m_state = WAIT_FOR_RETRANSMISSION;
+                    break;
+                }
+            }
+        }
+        break;
+
+    case WAIT_FOR_RETRANSMISSION:
+        for (int i = 0; i < results.size(); i++)
+        {
+            if (results[i].m_frequency == m_activeFrequency)
+            {
+                if (m_guiMessageQueue) {
+                    m_guiMessageQueue->push(MsgReportActivePower::create(results[i].m_power));
+                }
+
+                // Check if power has returned to being above threshold
+                if (results[i].m_power >= m_settings.m_threshold)
+                {
+                    m_timeoutTimer.stop();
+                    m_state = WAIT_FOR_END_TX;
+                }
+            }
+        }
+        break;
+
+    }
+}
+
+void FreqScanner::timeout()
+{
+    // Power hasn't returned above threshold - Restart scan
+    initScan();
+}
+
+void FreqScanner::setCenterFrequency(qint64 frequency)
+{
+    FreqScannerSettings settings = m_settings;
+    settings.m_inputFrequencyOffset = frequency;
+    applySettings(settings, {"inputFrequencyOffset"}, false);
+
+    if (m_guiMessageQueue) // forward to GUI if any
+    {
+        MsgConfigureFreqScanner *msgToGUI = MsgConfigureFreqScanner::create(settings, {"inputFrequencyOffset"}, false);
+        m_guiMessageQueue->push(msgToGUI);
+    }
+}
+
+void FreqScanner::applySettings(const FreqScannerSettings& settings, const QStringList& settingsKeys, bool force)
+{
+    qDebug() << "FreqScanner::applySettings:"
+            << settings.getDebugString(settingsKeys, force)
+            << " force: " << force;
+
+    if (settingsKeys.contains("streamIndex"))
+    {
+        if (m_deviceAPI->getSampleMIMO()) // change of stream is possible for MIMO devices only
+        {
+            m_deviceAPI->removeChannelSinkAPI(this);
+            m_deviceAPI->removeChannelSink(this, m_settings.m_streamIndex);
+            m_deviceAPI->addChannelSink(this, settings.m_streamIndex);
+            m_deviceAPI->addChannelSinkAPI(this);
+        }
+    }
+
+    if (settingsKeys.contains("channel") || force)
+    {
+        const QRegExp re("R([0-9]+):([0-9]+)");
+        if (re.indexIn(settings.m_channel) >= 0)
+        {
+            m_scanDeviceSetIndex = re.capturedTexts()[1].toInt();
+            m_scanChannelIndex = re.capturedTexts()[2].toInt();
+        }
+        else
+        {
+            qDebug() << "FreqScanner::applySettings: Failed to parse channel" << settings.m_channel;
+        }
+    }
+
+    if (m_running)
+    {
+        FreqScannerBaseband::MsgConfigureFreqScannerBaseband *msg = FreqScannerBaseband::MsgConfigureFreqScannerBaseband::create(settings, settingsKeys, force);
+        m_basebandSink->getInputMessageQueue()->push(msg);
+    }
+
+    if (settingsKeys.contains("useReverseAPI"))
+    {
+        bool fullUpdate = (settingsKeys.contains("useReverseAPI") && settings.m_useReverseAPI) ||
+            settingsKeys.contains("reverseAPIAddress") ||
+            settingsKeys.contains("reverseAPIPort") ||
+            settingsKeys.contains("reverseAPIDeviceIndex") ||
+            settingsKeys.contains("reverseAPIChannelIndex");
+        webapiReverseSendSettings(settingsKeys, settings, fullUpdate || force);
+    }
+
+    if (settingsKeys.contains("frequencies")
+        || settingsKeys.contains("enabled")
+        || settingsKeys.contains("priority")
+        || settingsKeys.contains("measurement")
+        || settingsKeys.contains("mode")
+        || force)
+    {
+        // Restart scan if any settings change
+        if (m_state != IDLE) {
+            m_state = START_SCAN;
+        }
+    }
+
+    if (force) {
+        m_settings = settings;
+    } else {
+        m_settings.applySettings(settingsKeys, settings);
+    }
+}
+
+QByteArray FreqScanner::serialize() const
+{
+    return m_settings.serialize();
+}
+
+bool FreqScanner::deserialize(const QByteArray& data)
+{
+    if (m_settings.deserialize(data))
+    {
+        MsgConfigureFreqScanner *msg = MsgConfigureFreqScanner::create(m_settings, QStringList(), true);
+        m_inputMessageQueue.push(msg);
+        return true;
+    }
+    else
+    {
+        m_settings.resetToDefaults();
+        MsgConfigureFreqScanner *msg = MsgConfigureFreqScanner::create(m_settings, QStringList(), true);
+        m_inputMessageQueue.push(msg);
+        return false;
+    }
+}
+
+int FreqScanner::webapiSettingsGet(
+        SWGSDRangel::SWGChannelSettings& response,
+        QString& errorMessage)
+{
+    (void) errorMessage;
+    /*response.ssetFreqScannerSettings(new SWGSDRangel::SWGFreqScannerSettings());
+    response.gsetFreqScannerSettings()->init();
+    webapiFormatChannelSettings(response, m_settings);*/
+    return 200;
+}
+
+int FreqScanner::webapiWorkspaceGet(
+        SWGSDRangel::SWGWorkspaceInfo& response,
+        QString& errorMessage)
+{
+    (void) errorMessage;
+    response.setIndex(m_settings.m_workspaceIndex);
+    return 200;
+}
+
+int FreqScanner::webapiSettingsPutPatch(
+        bool force,
+        const QStringList& channelSettingsKeys,
+        SWGSDRangel::SWGChannelSettings& response,
+        QString& errorMessage)
+{
+    (void) errorMessage;
+    FreqScannerSettings settings = m_settings;
+    webapiUpdateChannelSettings(settings, channelSettingsKeys, response);
+
+    MsgConfigureFreqScanner *msg = MsgConfigureFreqScanner::create(settings, channelSettingsKeys, force);
+    m_inputMessageQueue.push(msg);
+
+    qDebug("FreqScanner::webapiSettingsPutPatch: forward to GUI: %p", m_guiMessageQueue);
+    if (m_guiMessageQueue) // forward to GUI if any
+    {
+        MsgConfigureFreqScanner *msgToGUI = MsgConfigureFreqScanner::create(settings, channelSettingsKeys, force);
+        m_guiMessageQueue->push(msgToGUI);
+    }
+
+    webapiFormatChannelSettings(response, settings);
+
+    return 200;
+}
+
+int FreqScanner::webapiReportGet(
+            SWGSDRangel::SWGChannelReport& response,
+            QString& errorMessage)
+{
+    (void) errorMessage;
+    /*response.ssetFreqScannerReport(new SWGSDRangel::SWGFreqScannerReport());
+    response.gsetFreqScannerReport()->init();
+    webapiFormatChannelReport(response);*/
+    return 200;
+}
+
+void FreqScanner::webapiUpdateChannelSettings(
+        FreqScannerSettings& settings,
+        const QStringList& channelSettingsKeys,
+        SWGSDRangel::SWGChannelSettings& response)
+{
+    /*if (channelSettingsKeys.contains("inputFrequencyOffset")) {
+        settings.m_inputFrequencyOffset = response.gsetFreqScannerSettings()->getInputFrequencyOffset();
+    }
+    if (channelSettingsKeys.contains("rfBandwidth")) {
+        settings.m_channelBandwidth = response.gsetFreqScannerSettings()->getRfBandwidth();
+    }
+    if (channelSettingsKeys.contains("audioMute")) {
+        settings.m_audioMute = response.gsetFreqScannerSettings()->getAudioMute();
+    }
+    if (channelSettingsKeys.contains("threshold")) {
+        settings.m_threshold = response.gsetFreqScannerSettings()->getThreshold();
+    }
+    if (channelSettingsKeys.contains("logFilename")) {
+        settings.m_logFilename = *response.getAdsbDemodSettings()->getLogFilename();
+    }
+    if (channelSettingsKeys.contains("logEnabled")) {
+        settings.m_logEnabled = response.getAdsbDemodSettings()->getLogEnabled();
+    }
+    if (channelSettingsKeys.contains("rgbColor")) {
+        settings.m_rgbColor = response.gsetFreqScannerSettings()->getRgbColor();
+    }
+    if (channelSettingsKeys.contains("title")) {
+        settings.m_title = *response.gsetFreqScannerSettings()->getTitle();
+    }
+    if (channelSettingsKeys.contains("streamIndex")) {
+        settings.m_streamIndex = response.gsetFreqScannerSettings()->getStreamIndex();
+    }
+    if (channelSettingsKeys.contains("useReverseAPI")) {
+        settings.m_useReverseAPI = response.gsetFreqScannerSettings()->getUseReverseApi() != 0;
+    }
+    if (channelSettingsKeys.contains("reverseAPIAddress")) {
+        settings.m_reverseAPIAddress = *response.gsetFreqScannerSettings()->getReverseApiAddress();
+    }
+    if (channelSettingsKeys.contains("reverseAPIPort")) {
+        settings.m_reverseAPIPort = response.gsetFreqScannerSettings()->getReverseApiPort();
+    }
+    if (channelSettingsKeys.contains("reverseAPIDeviceIndex")) {
+        settings.m_reverseAPIDeviceIndex = response.gsetFreqScannerSettings()->getReverseApiDeviceIndex();
+    }
+    if (channelSettingsKeys.contains("reverseAPIChannelIndex")) {
+        settings.m_reverseAPIChannelIndex = response.gsetFreqScannerSettings()->getReverseApiChannelIndex();
+    }
+    if (settings.m_scopeGUI && channelSettingsKeys.contains("scopeConfig")) {
+        settings.m_scopeGUI->updateFrom(channelSettingsKeys, response.gsetFreqScannerSettings()->getScopeConfig());
+    }
+    if (settings.m_channelMarker && channelSettingsKeys.contains("channelMarker")) {
+        settings.m_channelMarker->updateFrom(channelSettingsKeys, response.gsetFreqScannerSettings()->getChannelMarker());
+    }
+    if (settings.m_rollupState && channelSettingsKeys.contains("rollupState")) {
+        settings.m_rollupState->updateFrom(channelSettingsKeys, response.gsetFreqScannerSettings()->getRollupState());
+    }*/
+}
+
+void FreqScanner::webapiFormatChannelSettings(SWGSDRangel::SWGChannelSettings& response, const FreqScannerSettings& settings)
+{
+    /*response.gsetFreqScannerSettings()->setInputFrequencyOffset(settings.m_inputFrequencyOffset);
+    response.gsetFreqScannerSettings()->setRfBandwidth(settings.m_channelBandwidth);
+    response.gsetFreqScannerSettings()->setAudioMute(settings.m_audioMute);
+    response.gsetFreqScannerSettings()->setThreshold(settings.m_threshold);
+    response.gsetFreqScannerSettings()->setLogFilename(new QString(settings.m_logFilename));
+    response.gsetFreqScannerSettings()->setLogEnabled(settings.m_logEnabled);
+
+    response.gsetFreqScannerSettings()->setRgbColor(settings.m_rgbColor);
+    if (response.gsetFreqScannerSettings()->getTitle()) {
+        *response.gsetFreqScannerSettings()->getTitle() = settings.m_title;
+    } else {
+        response.gsetFreqScannerSettings()->setTitle(new QString(settings.m_title));
+    }
+
+    response.gsetFreqScannerSettings()->setStreamIndex(settings.m_streamIndex);
+    response.gsetFreqScannerSettings()->setUseReverseApi(settings.m_useReverseAPI ? 1 : 0);
+
+    if (response.gsetFreqScannerSettings()->getReverseApiAddress()) {
+        *response.gsetFreqScannerSettings()->getReverseApiAddress() = settings.m_reverseAPIAddress;
+    } else {
+        response.gsetFreqScannerSettings()->setReverseApiAddress(new QString(settings.m_reverseAPIAddress));
+    }
+
+    response.gsetFreqScannerSettings()->setReverseApiPort(settings.m_reverseAPIPort);
+    response.gsetFreqScannerSettings()->setReverseApiDeviceIndex(settings.m_reverseAPIDeviceIndex);
+    response.gsetFreqScannerSettings()->setReverseApiChannelIndex(settings.m_reverseAPIChannelIndex);
+
+    if (settings.m_scopeGUI)
+    {
+        if (response.gsetFreqScannerSettings()->getScopeConfig())
+        {
+            settings.m_scopeGUI->formatTo(response.gsetFreqScannerSettings()->getScopeConfig());
+        }
+        else
+        {
+            SWGSDRangel::SWGGLScope *swgGLScope = new SWGSDRangel::SWGGLScope();
+            settings.m_scopeGUI->formatTo(swgGLScope);
+            response.gsetFreqScannerSettings()->setScopeConfig(swgGLScope);
+        }
+    }
+    if (settings.m_channelMarker)
+    {
+        if (response.gsetFreqScannerSettings()->getChannelMarker())
+        {
+            settings.m_channelMarker->formatTo(response.gsetFreqScannerSettings()->getChannelMarker());
+        }
+        else
+        {
+            SWGSDRangel::SWGChannelMarker *swgChannelMarker = new SWGSDRangel::SWGChannelMarker();
+            settings.m_channelMarker->formatTo(swgChannelMarker);
+            response.gsetFreqScannerSettings()->setChannelMarker(swgChannelMarker);
+        }
+    }
+
+    if (settings.m_rollupState)
+    {
+        if (response.gsetFreqScannerSettings()->getRollupState())
+        {
+            settings.m_rollupState->formatTo(response.gsetFreqScannerSettings()->getRollupState());
+        }
+        else
+        {
+            SWGSDRangel::SWGRollupState *swgRollupState = new SWGSDRangel::SWGRollupState();
+            settings.m_rollupState->formatTo(swgRollupState);
+            response.gsetFreqScannerSettings()->setRollupState(swgRollupState);
+        }
+    }*/
+}
+
+void FreqScanner::webapiFormatChannelReport(SWGSDRangel::SWGChannelReport& response)
+{
+    /*response.gsetFreqScannerReport()->setChannelPowerDb(CalcDb::dbPower(magsqAvg));
+    response.gsetFreqScannerReport()->setChannelSampleRate(m_basebandSink->getChannelSampleRate());*/
+}
+
+void FreqScanner::webapiReverseSendSettings(const QStringList& channelSettingsKeys, const FreqScannerSettings& settings, bool force)
+{
+    SWGSDRangel::SWGChannelSettings *swgChannelSettings = new SWGSDRangel::SWGChannelSettings();
+    webapiFormatChannelSettings(channelSettingsKeys, swgChannelSettings, settings, force);
+
+    QString channelSettingsURL = QString("http://%1:%2/sdrangel/deviceset/%3/channel/%4/settings")
+            .arg(settings.m_reverseAPIAddress)
+            .arg(settings.m_reverseAPIPort)
+            .arg(settings.m_reverseAPIDeviceIndex)
+            .arg(settings.m_reverseAPIChannelIndex);
+    m_networkRequest.setUrl(QUrl(channelSettingsURL));
+    m_networkRequest.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
+
+    QBuffer *buffer = new QBuffer();
+    buffer->open((QBuffer::ReadWrite));
+    buffer->write(swgChannelSettings->asJson().toUtf8());
+    buffer->seek(0);
+
+    // Always use PATCH to avoid passing reverse API settings
+    QNetworkReply *reply = m_networkManager->sendCustomRequest(m_networkRequest, "PATCH", buffer);
+    buffer->setParent(reply);
+
+    delete swgChannelSettings;
+}
+
+void FreqScanner::webapiFormatChannelSettings(
+        const QStringList& channelSettingsKeys,
+        SWGSDRangel::SWGChannelSettings *swgChannelSettings,
+        const FreqScannerSettings& settings,
+        bool force
+)
+{
+    /*swgChannelSettings->setDirection(0); // Single sink (Rx)
+    swgChannelSettings->setOriginatorChannelIndex(getIndexInDeviceSet());
+    swgChannelSettings->setOriginatorDeviceSetIndex(getDeviceSetIndex());
+    swgChannelSettings->setChannelType(new QString("FreqScanner"));
+    swgChannelSettings->ssetFreqScannerSettings(new SWGSDRangel::SWGFreqScannerSettings());
+    SWGSDRangel::SWGFreqScannerSettings *swgFreqScannerSettings = swgChannelSettings->gsetFreqScannerSettings();
+
+    // transfer data that has been modified. When force is on transfer all data except reverse API data
+
+    if (channelSettingsKeys.contains("inputFrequencyOffset") || force) {
+        swgFreqScannerSettings->setInputFrequencyOffset(settings.m_inputFrequencyOffset);
+    }
+    if (channelSettingsKeys.contains("rfBandwidth") || force) {
+        swgFreqScannerSettings->setRfBandwidth(settings.m_channelBandwidth);
+    }
+    if (channelSettingsKeys.contains("audioMute") || force) {
+        swgFreqScannerSettings->setAudioMute(settings.m_audioMute);
+    }
+    if (channelSettingsKeys.contains("threshold") || force) {
+        swgFreqScannerSettings->setThreshold(settings.m_threshold);
+    }
+    if (channelSettingsKeys.contains("logFilename") || force) {
+        swgFreqScannerSettings->setLogFilename(new QString(settings.m_logFilename));
+    }
+    if (channelSettingsKeys.contains("logEnabled") || force) {
+        swgFreqScannerSettings->setLogEnabled(settings.m_logEnabled);
+    }
+    if (channelSettingsKeys.contains("rgbColor") || force) {
+        swgFreqScannerSettings->setRgbColor(settings.m_rgbColor);
+    }
+    if (channelSettingsKeys.contains("title") || force) {
+        swgFreqScannerSettings->setTitle(new QString(settings.m_title));
+    }
+    if (channelSettingsKeys.contains("streamIndex") || force) {
+        swgFreqScannerSettings->setStreamIndex(settings.m_streamIndex);
+    }
+
+    if (settings.m_scopeGUI && (channelSettingsKeys.contains("scopeConfig") || force))
+    {
+        SWGSDRangel::SWGGLScope *swgGLScope = new SWGSDRangel::SWGGLScope();
+        settings.m_scopeGUI->formatTo(swgGLScope);
+        swgFreqScannerSettings->setScopeConfig(swgGLScope);
+    }
+
+    if (settings.m_channelMarker && (channelSettingsKeys.contains("channelMarker") || force))
+    {
+        SWGSDRangel::SWGChannelMarker *swgChannelMarker = new SWGSDRangel::SWGChannelMarker();
+        settings.m_channelMarker->formatTo(swgChannelMarker);
+        swgFreqScannerSettings->setChannelMarker(swgChannelMarker);
+    }
+
+    if (settings.m_rollupState && (channelSettingsKeys.contains("rollupState") || force))
+    {
+        SWGSDRangel::SWGRollupState *swgRollupState = new SWGSDRangel::SWGRollupState();
+        settings.m_rollupState->formatTo(swgRollupState);
+        swgFreqScannerSettings->setRollupState(swgRollupState);
+    }*/
+}
+
+void FreqScanner::networkManagerFinished(QNetworkReply *reply)
+{
+    QNetworkReply::NetworkError replyError = reply->error();
+
+    if (replyError)
+    {
+        qWarning() << "FreqScanner::networkManagerFinished:"
+                << " error(" << (int) replyError
+                << "): " << replyError
+                << ": " << reply->errorString();
+    }
+    else
+    {
+        QString answer = reply->readAll();
+        answer.chop(1); // remove last \n
+        qDebug("FreqScanner::networkManagerFinished: reply:\n%s", answer.toStdString().c_str());
+    }
+
+    reply->deleteLater();
+}
+
+void FreqScanner::handleIndexInDeviceSetChanged(int index)
+{
+    if (!m_running || (index < 0)) {
+        return;
+    }
+
+    QString fifoLabel = QString("%1 [%2:%3]")
+        .arg(m_channelId)
+        .arg(m_deviceAPI->getDeviceSetIndex())
+        .arg(index);
+    m_basebandSink->setFifoLabel(fifoLabel);
+}
+
+void FreqScanner::scanAvailableChannels()
+{
+    MainCore* mainCore = MainCore::instance();
+    MessagePipes& messagePipes = mainCore->getMessagePipes();
+    std::vector<DeviceSet*>& deviceSets = mainCore->getDeviceSets();
+    m_availableChannels.clear();
+
+    for (const auto& deviceSet : deviceSets)
+    {
+        DSPDeviceSourceEngine* deviceSourceEngine = deviceSet->m_deviceSourceEngine;
+
+        if (deviceSourceEngine)
+        {
+            for (int chi = 0; chi < deviceSet->getNumberOfChannels(); chi++)
+            {
+                ChannelAPI* channel = deviceSet->getChannelAt(chi);
+
+                FreqScannerSettings::AvailableChannel availableChannel =
+                    FreqScannerSettings::AvailableChannel{ channel->getDeviceSetIndex(), channel->getIndexInDeviceSet(), channel };
+                m_availableChannels[channel] = availableChannel;
+            }
+        }
+    }
+
+    notifyUpdateChannels();
+}
+
+void FreqScanner::handleChannelAdded(int deviceSetIndex, ChannelAPI* channel)
+{
+    qDebug("FreqScanner::handleChannelAdded: deviceSetIndex: %d:%d channel: %s (%p)",
+        deviceSetIndex, channel->getIndexInDeviceSet(), qPrintable(channel->getURI()), channel);
+    std::vector<DeviceSet*>& deviceSets = MainCore::instance()->getDeviceSets();
+    DeviceSet* deviceSet = deviceSets[deviceSetIndex];
+    DSPDeviceSourceEngine* deviceSourceEngine = deviceSet->m_deviceSourceEngine;
+
+    if (deviceSourceEngine)
+    {
+        FreqScannerSettings::AvailableChannel availableChannel =
+            FreqScannerSettings::AvailableChannel{ deviceSetIndex, channel->getIndexInDeviceSet(), channel };
+        m_availableChannels[channel] = availableChannel;
+    }
+
+    notifyUpdateChannels();
+}
+
+void FreqScanner::handleChannelRemoved(int deviceSetIndex, ChannelAPI* channel)
+{
+    qDebug("FreqScanner::handleChannelRemoved: deviceSetIndex: %d:%d channel: %s (%p)",
+        deviceSetIndex, channel->getIndexInDeviceSet(), qPrintable(channel->getURI()), channel);
+    std::vector<DeviceSet*>& deviceSets = MainCore::instance()->getDeviceSets();
+    DeviceSet* deviceSet = deviceSets[deviceSetIndex];
+    DSPDeviceSourceEngine* deviceSourceEngine = deviceSet->m_deviceSourceEngine;
+
+    if (deviceSourceEngine) {
+        m_availableChannels.remove(channel);
+    }
+
+    notifyUpdateChannels();
+}
+
+void FreqScanner::notifyUpdateChannels()
+{
+    if (getMessageQueueToGUI())
+    {
+        MsgReportChannels* msgToGUI = MsgReportChannels::create();
+        QList<FreqScannerSettings::AvailableChannel>& msgChannels = msgToGUI->getChannels();
+        QHash<ChannelAPI*, FreqScannerSettings::AvailableChannel>::iterator it = m_availableChannels.begin();
+
+        for (; it != m_availableChannels.end(); ++it)
+        {
+            FreqScannerSettings::AvailableChannel msgChannel =
+                FreqScannerSettings::AvailableChannel{
+                    it->m_deviceSetIndex,
+                    it->m_channelIndex
+            };
+            msgChannels.push_back(msgChannel);
+        }
+
+        getMessageQueueToGUI()->push(msgToGUI);
+    }
+}
diff --git a/plugins/channelrx/freqscanner/freqscanner.h b/plugins/channelrx/freqscanner/freqscanner.h
new file mode 100644
index 000000000..ff294b161
--- /dev/null
+++ b/plugins/channelrx/freqscanner/freqscanner.h
@@ -0,0 +1,435 @@
+///////////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2015-2018 Edouard Griffiths, F4EXB.                             //
+// Copyright (C) 2023 Jon Beniston, M7RCE                                        //
+//                                                                               //
+// This program is free software; you can redistribute it and/or modify          //
+// it under the terms of the GNU General Public License as published by          //
+// the Free Software Foundation as version 3 of the License, or                  //
+// (at your option) any later version.                                           //
+//                                                                               //
+// This program is distributed in the hope that it will be useful,               //
+// but WITHOUT ANY WARRANTY; without even the implied warranty of                //
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                  //
+// GNU General Public License V3 for more details.                               //
+//                                                                               //
+// You should have received a copy of the GNU General Public License             //
+// along with this program. If not, see <http://www.gnu.org/licenses/>.          //
+///////////////////////////////////////////////////////////////////////////////////
+
+#ifndef INCLUDE_FREQSCANNER_H
+#define INCLUDE_FREQSCANNER_H
+
+#include <QNetworkRequest>
+#include <QThread>
+#include <QTimer>
+#include <QDateTime>
+#include <QDebug>
+
+#include "dsp/basebandsamplesink.h"
+#include "channel/channelapi.h"
+#include "util/message.h"
+
+#include "freqscannerbaseband.h"
+#include "freqscannersettings.h"
+
+class QNetworkAccessManager;
+class QNetworkReply;
+class QThread;
+class DeviceAPI;
+
+class FreqScanner : public BasebandSampleSink, public ChannelAPI {
+public:
+    class MsgConfigureFreqScanner : public Message {
+        MESSAGE_CLASS_DECLARATION
+
+    public:
+        const FreqScannerSettings& getSettings() const { return m_settings; }
+        const QStringList& getSettingsKeys() const { return m_settingsKeys; }
+        bool getForce() const { return m_force; }
+
+        static MsgConfigureFreqScanner* create(const FreqScannerSettings& settings, const QStringList& settingsKeys, bool force)
+        {
+            return new MsgConfigureFreqScanner(settings, settingsKeys, force);
+        }
+
+    private:
+        FreqScannerSettings m_settings;
+        QStringList m_settingsKeys;
+        bool m_force;
+
+        MsgConfigureFreqScanner(const FreqScannerSettings& settings, const QStringList& settingsKeys, bool force) :
+            Message(),
+            m_settings(settings),
+            m_settingsKeys(settingsKeys),
+            m_force(force)
+        { }
+    };
+
+    class MsgReportChannels : public Message {
+        MESSAGE_CLASS_DECLARATION
+
+    public:
+
+        QList<FreqScannerSettings::AvailableChannel>& getChannels() { return m_channels; }
+
+        static MsgReportChannels* create() {
+            return new MsgReportChannels();
+        }
+
+    private:
+        QList<FreqScannerSettings::AvailableChannel> m_channels;
+
+        MsgReportChannels() :
+            Message()
+        {}
+    };
+
+    class MsgStartScan : public Message {
+        MESSAGE_CLASS_DECLARATION
+
+    public:
+
+        static MsgStartScan* create()
+        {
+            return new MsgStartScan();
+        }
+
+    private:
+
+        MsgStartScan() :
+            Message()
+        {
+        }
+    };
+
+    class MsgStopScan : public Message {
+        MESSAGE_CLASS_DECLARATION
+
+    public:
+
+        static MsgStopScan* create()
+        {
+            return new MsgStopScan();
+        }
+
+    private:
+
+        MsgStopScan() :
+            Message()
+        {
+        }
+    };
+
+    class MsgScanComplete : public Message {
+        MESSAGE_CLASS_DECLARATION
+
+    public:
+
+        static MsgScanComplete* create()
+        {
+            return new MsgScanComplete();
+        }
+
+    private:
+
+        MsgScanComplete() :
+            Message()
+        {
+        }
+    };
+
+    class MsgScanResult : public Message {
+        MESSAGE_CLASS_DECLARATION
+
+    public:
+
+        struct ScanResult {
+            qint64 m_frequency;
+            float m_power;
+        };
+
+        const QDateTime& getFFTStartTime() { return m_fftStartTime; }
+        QList<ScanResult>& getScanResults() { return m_scanResults; }
+
+        static MsgScanResult* create(const QDateTime& fftStartTime) {
+            return new MsgScanResult(fftStartTime);
+        }
+
+    private:
+        QDateTime m_fftStartTime;
+        QList<ScanResult> m_scanResults;
+
+        MsgScanResult(const QDateTime& fftStartTime) :
+            Message(),
+            m_fftStartTime(fftStartTime)
+        {}
+    };
+
+    class MsgStatus : public Message {
+        MESSAGE_CLASS_DECLARATION
+
+    public:
+
+        const QString& getText() const { return m_text; }
+
+        static MsgStatus* create(const QString& text)
+        {
+            return new MsgStatus(text);
+        }
+
+    private:
+
+        QString m_text;
+
+        MsgStatus(const QString& text) :
+            Message(),
+            m_text(text)
+        {
+        }
+    };
+
+    class MsgReportActiveFrequency : public Message {
+        MESSAGE_CLASS_DECLARATION
+
+    public:
+
+        qint64 getCenterFrequency() const { return m_centerFrequency; }
+
+        static MsgReportActiveFrequency* create(qint64 centerFrequency)
+        {
+            return new MsgReportActiveFrequency(centerFrequency);
+        }
+
+    private:
+
+        qint64 m_centerFrequency;
+
+        MsgReportActiveFrequency(qint64 centerFrequency) :
+            Message(),
+            m_centerFrequency(centerFrequency)
+        {
+        }
+    };
+
+    class MsgReportActivePower : public Message {
+        MESSAGE_CLASS_DECLARATION
+
+    public:
+
+        float getPower() const { return m_power; }
+
+        static MsgReportActivePower* create(float power)
+        {
+            return new MsgReportActivePower(power);
+        }
+
+    private:
+
+        Real m_power;
+
+        MsgReportActivePower(float power) :
+            Message(),
+            m_power(power)
+        {
+        }
+    };
+
+    class MsgReportScanning : public Message {
+        MESSAGE_CLASS_DECLARATION
+
+    public:
+
+        static MsgReportScanning* create()
+        {
+            return new MsgReportScanning();
+        }
+
+    private:
+
+        MsgReportScanning() :
+            Message()
+        {
+        }
+    };
+
+    class MsgReportScanRange : public Message {
+        MESSAGE_CLASS_DECLARATION
+
+    public:
+
+        qint64 getCenterFrequency() const { return m_centerFrequency; }
+        int getTotalBandwidth() const { return m_totalBandwidth; }
+        int getFftSize() const { return m_fftSize; }
+
+        static MsgReportScanRange* create(qint64 centerFrequency, int totalBandwidth, int fftSize)
+        {
+            return new MsgReportScanRange(centerFrequency, totalBandwidth, fftSize);
+        }
+
+    private:
+
+        qint64 m_centerFrequency;
+        int m_totalBandwidth;
+        int m_fftSize;
+
+        MsgReportScanRange(qint64 centerFrequency, int totalBandwidth, int fftSize) :
+            Message(),
+            m_centerFrequency(centerFrequency),
+            m_totalBandwidth(totalBandwidth),
+            m_fftSize(fftSize)
+        {
+        }
+    };
+
+    FreqScanner(DeviceAPI *deviceAPI);
+    virtual ~FreqScanner();
+    virtual void destroy() { delete this; }
+    virtual void setDeviceAPI(DeviceAPI *deviceAPI);
+    virtual DeviceAPI *getDeviceAPI() { return m_deviceAPI; }
+
+    using BasebandSampleSink::feed;
+    virtual void feed(const SampleVector::const_iterator& begin, const SampleVector::const_iterator& end, bool po);
+    virtual void start();
+    virtual void stop();
+    virtual void pushMessage(Message *msg) { m_inputMessageQueue.push(msg); }
+    virtual QString getSinkName() { return objectName(); }
+
+    virtual void getIdentifier(QString& id) { id = objectName(); }
+    virtual QString getIdentifier() const { return objectName(); }
+    virtual const QString& getURI() const { return getName(); }
+    virtual void getTitle(QString& title) { title = m_settings.m_title; }
+    virtual qint64 getCenterFrequency() const { return m_settings.m_inputFrequencyOffset; }
+    virtual void setCenterFrequency(qint64 frequency);
+
+    virtual QByteArray serialize() const;
+    virtual bool deserialize(const QByteArray& data);
+
+    virtual int getNbSinkStreams() const { return 1; }
+    virtual int getNbSourceStreams() const { return 0; }
+
+    virtual qint64 getStreamCenterFrequency(int streamIndex, bool sinkElseSource) const
+    {
+        (void) streamIndex;
+        (void) sinkElseSource;
+        return 0;
+    }
+
+    virtual int webapiSettingsGet(
+            SWGSDRangel::SWGChannelSettings& response,
+            QString& errorMessage);
+
+    virtual int webapiWorkspaceGet(
+            SWGSDRangel::SWGWorkspaceInfo& response,
+            QString& errorMessage);
+
+    virtual int webapiSettingsPutPatch(
+            bool force,
+            const QStringList& channelSettingsKeys,
+            SWGSDRangel::SWGChannelSettings& response,
+            QString& errorMessage);
+
+    virtual int webapiReportGet(
+            SWGSDRangel::SWGChannelReport& response,
+            QString& errorMessage);
+
+    static void webapiFormatChannelSettings(
+            SWGSDRangel::SWGChannelSettings& response,
+            const FreqScannerSettings& settings);
+
+    static void webapiUpdateChannelSettings(
+            FreqScannerSettings& settings,
+            const QStringList& channelSettingsKeys,
+            SWGSDRangel::SWGChannelSettings& response);
+
+    void setMessageQueueToGUI(MessageQueue* queue) override {
+        ChannelAPI::setMessageQueueToGUI(queue);
+        m_basebandSink->setMessageQueueToGUI(queue);
+    }
+
+    uint32_t getNumberOfDeviceStreams() const;
+
+    static void calcScannerSampleRate(int channelBW, int basebandSampleRate, int& scannerSampleRate, int& fftSize, int& binsPerChannel)
+    {
+        const int maxFFTSize = 2048;
+        const int maxBinsPerChannel = 32;
+        const int minBinsPerChannel = 8;
+
+        // Use multiple bins per channel, to account for FFT spectral leakage
+        binsPerChannel = maxFFTSize / (basebandSampleRate / channelBW);
+        binsPerChannel = std::min(binsPerChannel, maxBinsPerChannel);
+        binsPerChannel = std::max(binsPerChannel, minBinsPerChannel);
+        double binBW = channelBW / (double)binsPerChannel;
+
+        // Find next smallest power of 2
+        fftSize = pow(2.0, floor(log2(basebandSampleRate / binBW)));
+        fftSize = std::min(maxFFTSize, fftSize);
+        scannerSampleRate = binBW * fftSize;
+        qInfo() << "binsPerChannel:" << binsPerChannel << "fftSize:" << fftSize << "scannerSampleRate:" << scannerSampleRate;
+    }
+
+    static const char * const m_channelIdURI;
+    static const char * const m_channelId;
+
+private:
+    DeviceAPI *m_deviceAPI;
+    QThread m_thread;
+    FreqScannerBaseband* m_basebandSink;
+    bool m_running;
+    FreqScannerSettings m_settings;
+    int m_basebandSampleRate; //!< stored from device message used when starting baseband sink
+    qint64 m_centerFrequency;
+
+    QNetworkAccessManager *m_networkManager;
+    QNetworkRequest m_networkRequest;
+
+    QHash<ChannelAPI*, FreqScannerSettings::AvailableChannel> m_availableChannels;
+
+    int m_scanDeviceSetIndex;
+    int m_scanChannelIndex;
+    qint64 m_activeFrequency;
+    QDateTime m_minFFTStartTime;
+    int m_scannerSampleRate;
+    bool m_stepping;
+    qint64 m_stepStartFrequency;
+    qint64 m_stepStopFrequency;
+    QList<MsgScanResult::ScanResult> m_scanResults;
+
+    enum State {
+        IDLE,
+        START_SCAN,
+        SCAN_FOR_MAX_POWER,
+        WAIT_FOR_END_TX,
+        WAIT_FOR_RETRANSMISSION
+    } m_state;
+
+    QTimer m_timeoutTimer;
+
+    virtual bool handleMessage(const Message& cmd);
+    void applySettings(const FreqScannerSettings& settings, const QStringList& settingsKeys, bool force = false);
+    void webapiReverseSendSettings(const QStringList& channelSettingsKeys, const FreqScannerSettings& settings, bool force);
+    void webapiFormatChannelSettings(
+        const QStringList& channelSettingsKeys,
+        SWGSDRangel::SWGChannelSettings *swgChannelSettings,
+        const FreqScannerSettings& settings,
+        bool force
+    );
+    void webapiFormatChannelReport(SWGSDRangel::SWGChannelReport& response);
+
+    void scanAvailableChannels();
+    void notifyUpdateChannels();
+    void startScan();
+    void stopScan();
+    void initScan();
+    void processScanResults(const QDateTime& fftStartTime, const QList<MsgScanResult::ScanResult>& results);
+
+private slots:
+    void networkManagerFinished(QNetworkReply *reply);
+    void handleIndexInDeviceSetChanged(int index);
+    void handleChannelAdded(int deviceSetIndex, ChannelAPI* channel);
+    void handleChannelRemoved(int deviceSetIndex, ChannelAPI* channel);
+    void timeout();
+
+};
+
+#endif // INCLUDE_FREQSCANNER_H
+
diff --git a/plugins/channelrx/freqscanner/freqscanneraddrangedialog.cpp b/plugins/channelrx/freqscanner/freqscanneraddrangedialog.cpp
new file mode 100644
index 000000000..afdd7e1e6
--- /dev/null
+++ b/plugins/channelrx/freqscanner/freqscanneraddrangedialog.cpp
@@ -0,0 +1,48 @@
+///////////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2023 Jon Beniston, M7RCE                                        //
+//                                                                               //
+// This program is free software; you can redistribute it and/or modify          //
+// it under the terms of the GNU General Public License as published by          //
+// the Free Software Foundation as version 3 of the License, or                  //
+// (at your option) any later version.                                           //
+//                                                                               //
+// This program is distributed in the hope that it will be useful,               //
+// but WITHOUT ANY WARRANTY; without even the implied warranty of                //
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                  //
+// GNU General Public License V3 for more details.                               //
+//                                                                               //
+// You should have received a copy of the GNU General Public License             //
+// along with this program. If not, see <http://www.gnu.org/licenses/>.          //
+///////////////////////////////////////////////////////////////////////////////////
+
+#include "freqscanneraddrangedialog.h"
+#include "ui_freqscanneraddrangedialog.h"
+
+FreqScannerAddRangeDialog::FreqScannerAddRangeDialog(QWidget* parent) :
+    QDialog(parent),
+    ui(new Ui::FreqScannerAddRangeDialog)
+{
+    ui->setupUi(this);
+
+    ui->start->setColorMapper(ColorMapper(ColorMapper::GrayGold));
+    ui->start->setValueRange(false, 11, 0, 99999999999);
+    ui->stop->setColorMapper(ColorMapper(ColorMapper::GrayGold));
+    ui->stop->setValueRange(false, 11, 0, 99999999999);
+
+    // Airband frequency range
+    ui->start->setValue(118000000);
+    ui->stop->setValue(137000000);
+}
+
+FreqScannerAddRangeDialog::~FreqScannerAddRangeDialog()
+{
+    delete ui;
+}
+
+void FreqScannerAddRangeDialog::accept()
+{
+    m_start = ui->start->getValue();
+    m_stop = ui->stop->getValue();
+    m_step = ui->step->currentText().toLongLong();
+    QDialog::accept();
+}
diff --git a/plugins/channelrx/freqscanner/freqscanneraddrangedialog.h b/plugins/channelrx/freqscanner/freqscanneraddrangedialog.h
new file mode 100644
index 000000000..8bacafe7f
--- /dev/null
+++ b/plugins/channelrx/freqscanner/freqscanneraddrangedialog.h
@@ -0,0 +1,44 @@
+///////////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2023 Jon Beniston, M7RCE                                        //
+//                                                                               //
+// This program is free software; you can redistribute it and/or modify          //
+// it under the terms of the GNU General Public License as published by          //
+// the Free Software Foundation as version 3 of the License, or                  //
+// (at your option) any later version.                                           //
+//                                                                               //
+// This program is distributed in the hope that it will be useful,               //
+// but WITHOUT ANY WARRANTY; without even the implied warranty of                //
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                  //
+// GNU General Public License V3 for more details.                               //
+//                                                                               //
+// You should have received a copy of the GNU General Public License             //
+// along with this program. If not, see <http://www.gnu.org/licenses/>.          //
+///////////////////////////////////////////////////////////////////////////////////
+
+#ifndef INCLUDE_FREQSCANNERADDRANGEDIALOG_H
+#define INCLUDE_FREQSCANNERADDRANGEDIALOG_H
+
+#include <QDialog>
+
+namespace Ui {
+    class FreqScannerAddRangeDialog;
+}
+
+class FreqScannerAddRangeDialog : public QDialog {
+    Q_OBJECT
+public:
+    explicit FreqScannerAddRangeDialog(QWidget* parent = nullptr);
+    ~FreqScannerAddRangeDialog();
+
+    qint64 m_start;
+    qint64 m_stop;
+    int m_step;
+
+private slots:
+    void accept();
+
+private:
+    Ui::FreqScannerAddRangeDialog *ui;
+};
+
+#endif // INCLUDE_FREQSCANNERADDRANGEDIALOG_H
diff --git a/plugins/channelrx/freqscanner/freqscanneraddrangedialog.ui b/plugins/channelrx/freqscanner/freqscanneraddrangedialog.ui
new file mode 100644
index 000000000..0cce5efe4
--- /dev/null
+++ b/plugins/channelrx/freqscanner/freqscanneraddrangedialog.ui
@@ -0,0 +1,222 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>FreqScannerAddRangeDialog</class>
+ <widget class="QDialog" name="FreqScannerAddRangeDialog">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>385</width>
+    <height>162</height>
+   </rect>
+  </property>
+  <property name="font">
+   <font>
+    <pointsize>9</pointsize>
+   </font>
+  </property>
+  <property name="windowTitle">
+   <string>Add Range</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <item>
+    <widget class="QGroupBox" name="groupBox">
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
+     <property name="title">
+      <string>Add Frequency Range</string>
+     </property>
+     <layout class="QGridLayout" name="gridLayout">
+      <item row="2" column="1">
+       <widget class="ValueDialZ" name="stop" native="true">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Expanding" vsizetype="Maximum">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="minimumSize">
+         <size>
+          <width>32</width>
+          <height>16</height>
+         </size>
+        </property>
+        <property name="font">
+         <font>
+          <family>Liberation Mono</family>
+          <pointsize>12</pointsize>
+         </font>
+        </property>
+        <property name="cursor">
+         <cursorShape>PointingHandCursor</cursorShape>
+        </property>
+        <property name="focusPolicy">
+         <enum>Qt::StrongFocus</enum>
+        </property>
+        <property name="toolTip">
+         <string>Stop frequency in Hertz</string>
+        </property>
+       </widget>
+      </item>
+      <item row="2" column="0">
+       <widget class="QLabel" name="stopLabel">
+        <property name="text">
+         <string>Stop Frequency</string>
+        </property>
+       </widget>
+      </item>
+      <item row="0" column="0">
+       <widget class="QLabel" name="startLabel">
+        <property name="minimumSize">
+         <size>
+          <width>90</width>
+          <height>0</height>
+         </size>
+        </property>
+        <property name="text">
+         <string>Start Frequency</string>
+        </property>
+       </widget>
+      </item>
+      <item row="2" column="2">
+       <widget class="QLabel" name="stopUnits">
+        <property name="text">
+         <string>Hz</string>
+        </property>
+       </widget>
+      </item>
+      <item row="3" column="1">
+       <widget class="QComboBox" name="step">
+        <property name="editable">
+         <bool>true</bool>
+        </property>
+        <item>
+         <property name="text">
+          <string>25000</string>
+         </property>
+        </item>
+        <item>
+         <property name="text">
+          <string>8333.3</string>
+         </property>
+        </item>
+       </widget>
+      </item>
+      <item row="0" column="1">
+       <widget class="ValueDialZ" name="start" native="true">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Expanding" vsizetype="Maximum">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="minimumSize">
+         <size>
+          <width>32</width>
+          <height>16</height>
+         </size>
+        </property>
+        <property name="font">
+         <font>
+          <family>Liberation Mono</family>
+          <pointsize>12</pointsize>
+         </font>
+        </property>
+        <property name="cursor">
+         <cursorShape>PointingHandCursor</cursorShape>
+        </property>
+        <property name="focusPolicy">
+         <enum>Qt::StrongFocus</enum>
+        </property>
+        <property name="toolTip">
+         <string>Start frequency in Hertz</string>
+        </property>
+       </widget>
+      </item>
+      <item row="3" column="2">
+       <widget class="QLabel" name="stepUnits">
+        <property name="text">
+         <string>Hz</string>
+        </property>
+       </widget>
+      </item>
+      <item row="0" column="2">
+       <widget class="QLabel" name="startUnits">
+        <property name="text">
+         <string>Hz</string>
+        </property>
+       </widget>
+      </item>
+      <item row="3" column="0">
+       <widget class="QLabel" name="stepLabel">
+        <property name="text">
+         <string>Step</string>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </widget>
+   </item>
+   <item>
+    <widget class="QDialogButtonBox" name="buttonBox">
+     <property name="orientation">
+      <enum>Qt::Horizontal</enum>
+     </property>
+     <property name="standardButtons">
+      <set>QDialogButtonBox::Cancel|QDialogButtonBox::Ok</set>
+     </property>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>ValueDialZ</class>
+   <extends>QWidget</extends>
+   <header>gui/valuedialz.h</header>
+   <container>1</container>
+  </customwidget>
+ </customwidgets>
+ <resources>
+  <include location="../../../sdrgui/resources/res.qrc"/>
+  <include location="../demodapt/icons.qrc"/>
+ </resources>
+ <connections>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>accepted()</signal>
+   <receiver>FreqScannerAddRangeDialog</receiver>
+   <slot>accept()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>248</x>
+     <y>254</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>157</x>
+     <y>274</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>rejected()</signal>
+   <receiver>FreqScannerAddRangeDialog</receiver>
+   <slot>reject()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>316</x>
+     <y>260</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>286</x>
+     <y>274</y>
+    </hint>
+   </hints>
+  </connection>
+ </connections>
+</ui>
diff --git a/plugins/channelrx/freqscanner/freqscannerbaseband.cpp b/plugins/channelrx/freqscanner/freqscannerbaseband.cpp
new file mode 100644
index 000000000..1516505f1
--- /dev/null
+++ b/plugins/channelrx/freqscanner/freqscannerbaseband.cpp
@@ -0,0 +1,215 @@
+///////////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2019 Edouard Griffiths, F4EXB                                   //
+// Copyright (C) 2023 Jon Beniston, M7RCE                                        //
+//                                                                               //
+// This program is free software; you can redistribute it and/or modify          //
+// it under the terms of the GNU General Public License as published by          //
+// the Free Software Foundation as version 3 of the License, or                  //
+// (at your option) any later version.                                           //
+//                                                                               //
+// This program is distributed in the hope that it will be useful,               //
+// but WITHOUT ANY WARRANTY; without even the implied warranty of                //
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                  //
+// GNU General Public License V3 for more details.                               //
+//                                                                               //
+// You should have received a copy of the GNU General Public License             //
+// along with this program. If not, see <http://www.gnu.org/licenses/>.          //
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <QDebug>
+
+#include "dsp/dspengine.h"
+#include "dsp/dspcommands.h"
+#include "dsp/downchannelizer.h"
+
+#include "freqscannerbaseband.h"
+#include "freqscanner.h"
+
+MESSAGE_CLASS_DEFINITION(FreqScannerBaseband::MsgConfigureFreqScannerBaseband, Message)
+
+FreqScannerBaseband::FreqScannerBaseband(FreqScanner *freqScanner) :
+    m_sink(freqScanner),
+    m_messageQueueToGUI(nullptr),
+    m_running(false)
+{
+    qDebug("FreqScannerBaseband::FreqScannerBaseband");
+
+    m_sampleFifo.setSize(SampleSinkFifo::getSizePolicy(48000));
+    m_channelizer = new DownChannelizer(&m_sink);
+    m_channelSampleRate = 0;
+    m_scannerSampleRate = 0;
+}
+
+FreqScannerBaseband::~FreqScannerBaseband()
+{
+    m_inputMessageQueue.clear();
+    delete m_channelizer;
+}
+
+void FreqScannerBaseband::reset()
+{
+    QMutexLocker mutexLocker(&m_mutex);
+    m_inputMessageQueue.clear();
+    m_sampleFifo.reset();
+    m_channelSampleRate = 0;
+}
+
+void FreqScannerBaseband::startWork()
+{
+    QMutexLocker mutexLocker(&m_mutex);
+    QObject::connect(
+        &m_sampleFifo,
+        &SampleSinkFifo::dataReady,
+        this,
+        &FreqScannerBaseband::handleData,
+        Qt::QueuedConnection
+    );
+    connect(&m_inputMessageQueue, SIGNAL(messageEnqueued()), this, SLOT(handleInputMessages()));
+    m_running = true;
+}
+
+void FreqScannerBaseband::stopWork()
+{
+    QMutexLocker mutexLocker(&m_mutex);
+    disconnect(&m_inputMessageQueue, SIGNAL(messageEnqueued()), this, SLOT(handleInputMessages()));
+    QObject::disconnect(
+        &m_sampleFifo,
+        &SampleSinkFifo::dataReady,
+        this,
+        &FreqScannerBaseband::handleData
+    );
+    m_running = false;
+}
+
+void FreqScannerBaseband::setChannel(ChannelAPI *channel)
+{
+    m_sink.setChannel(channel);
+}
+
+void FreqScannerBaseband::feed(const SampleVector::const_iterator& begin, const SampleVector::const_iterator& end)
+{
+    m_sampleFifo.write(begin, end);
+}
+
+void FreqScannerBaseband::handleData()
+{
+    QMutexLocker mutexLocker(&m_mutex);
+
+    while ((m_sampleFifo.fill() > 0) && (m_inputMessageQueue.size() == 0))
+    {
+        SampleVector::iterator part1begin;
+        SampleVector::iterator part1end;
+        SampleVector::iterator part2begin;
+        SampleVector::iterator part2end;
+
+        std::size_t count = m_sampleFifo.readBegin(m_sampleFifo.fill(), &part1begin, &part1end, &part2begin, &part2end);
+
+        // first part of FIFO data
+        if (part1begin != part1end) {
+            m_channelizer->feed(part1begin, part1end);
+        }
+
+        // second part of FIFO data (used when block wraps around)
+        if(part2begin != part2end) {
+            m_channelizer->feed(part2begin, part2end);
+        }
+
+        m_sampleFifo.readCommit((unsigned int) count);
+    }
+}
+
+void FreqScannerBaseband::handleInputMessages()
+{
+    Message* message;
+
+    while ((message = m_inputMessageQueue.pop()) != nullptr)
+    {
+        if (handleMessage(*message)) {
+            delete message;
+        }
+    }
+}
+
+bool FreqScannerBaseband::handleMessage(const Message& cmd)
+{
+    if (MsgConfigureFreqScannerBaseband::match(cmd))
+    {
+        QMutexLocker mutexLocker(&m_mutex);
+        MsgConfigureFreqScannerBaseband& cfg = (MsgConfigureFreqScannerBaseband&) cmd;
+        qDebug() << "FreqScannerBaseband::handleMessage: MsgConfigureFreqScannerBaseband";
+
+        applySettings(cfg.getSettings(), cfg.getSettingsKeys(), cfg.getForce());
+
+        return true;
+    }
+    else if (DSPSignalNotification::match(cmd))
+    {
+        QMutexLocker mutexLocker(&m_mutex);
+        DSPSignalNotification& notif = (DSPSignalNotification&) cmd;
+        qDebug() << "FreqScannerBaseband::handleMessage: DSPSignalNotification: basebandSampleRate: " << notif.getSampleRate();
+        setBasebandSampleRate(notif.getSampleRate());
+        m_sampleFifo.setSize(SampleSinkFifo::getSizePolicy(notif.getSampleRate()));
+        if (m_channelSampleRate != m_channelizer->getChannelSampleRate()) {
+            m_channelSampleRate = m_channelizer->getChannelSampleRate();
+        }
+        m_sink.setCenterFrequency(notif.getCenterFrequency());
+
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+void FreqScannerBaseband::applySettings(const FreqScannerSettings& settings, const QStringList& settingsKeys, bool force)
+{
+    if ((settings.m_channelBandwidth != m_settings.m_channelBandwidth) || (settings.m_inputFrequencyOffset != m_settings.m_inputFrequencyOffset) || force) {
+        calcScannerSampleRate(m_channelizer->getBasebandSampleRate(), settings.m_channelBandwidth, settings.m_inputFrequencyOffset);
+    }
+
+    m_sink.applySettings(settings, settingsKeys, force);
+
+    if (force) {
+        m_settings = settings;
+    } else {
+        m_settings.applySettings(settingsKeys, settings);
+    }
+}
+
+int FreqScannerBaseband::getChannelSampleRate() const
+{
+    return m_channelizer->getChannelSampleRate();
+}
+
+void FreqScannerBaseband::setBasebandSampleRate(int sampleRate)
+{
+    m_channelizer->setBasebandSampleRate(sampleRate);
+    calcScannerSampleRate(sampleRate, m_settings.m_channelBandwidth, m_settings.m_inputFrequencyOffset);
+}
+
+void FreqScannerBaseband::calcScannerSampleRate(int basebandSampleRate, float rfBandwidth, int inputFrequencyOffset)
+{
+    int fftSize;
+    int binsPerChannel;
+
+    FreqScanner::calcScannerSampleRate(rfBandwidth, basebandSampleRate, m_scannerSampleRate, fftSize, binsPerChannel);
+
+    m_channelizer->setChannelization(m_scannerSampleRate, inputFrequencyOffset);
+    m_channelSampleRate = m_channelizer->getChannelSampleRate();
+    m_sink.applyChannelSettings(m_channelSampleRate, m_channelizer->getChannelFrequencyOffset(), m_scannerSampleRate, fftSize, binsPerChannel);
+
+    qInfo() << "FreqScannerBaseband::calcScannerSampleRate"
+        << "basebandSampleRate:" << basebandSampleRate
+        << "channelSampleRate:" << m_channelSampleRate
+        << "scannerSampleRate:" << m_scannerSampleRate
+        << "rfBandwidth:" << rfBandwidth
+        << "fftSize:" << fftSize
+        << "binsPerChannel:" << binsPerChannel;
+
+    if (getMessageQueueToGUI())
+    {
+        FreqScanner::MsgReportScanRange* msg = FreqScanner::MsgReportScanRange::create(inputFrequencyOffset, m_scannerSampleRate, fftSize);
+        getMessageQueueToGUI()->push(msg);
+    }
+}
diff --git a/plugins/channelrx/freqscanner/freqscannerbaseband.h b/plugins/channelrx/freqscanner/freqscannerbaseband.h
new file mode 100644
index 000000000..739a2cf8d
--- /dev/null
+++ b/plugins/channelrx/freqscanner/freqscannerbaseband.h
@@ -0,0 +1,102 @@
+///////////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2019 Edouard Griffiths, F4EXB                                   //
+// Copyright (C) 2023 Jon Beniston, M7RCE                                        //
+//                                                                               //
+// This program is free software; you can redistribute it and/or modify          //
+// it under the terms of the GNU General Public License as published by          //
+// the Free Software Foundation as version 3 of the License, or                  //
+// (at your option) any later version.                                           //
+//                                                                               //
+// This program is distributed in the hope that it will be useful,               //
+// but WITHOUT ANY WARRANTY; without even the implied warranty of                //
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                  //
+// GNU General Public License V3 for more details.                               //
+//                                                                               //
+// You should have received a copy of the GNU General Public License             //
+// along with this program. If not, see <http://www.gnu.org/licenses/>.          //
+///////////////////////////////////////////////////////////////////////////////////
+
+#ifndef INCLUDE_FREQSCANNERBASEBAND_H
+#define INCLUDE_FREQSCANNERBASEBAND_H
+
+#include <QObject>
+#include <QRecursiveMutex>
+
+#include "dsp/samplesinkfifo.h"
+#include "util/message.h"
+#include "util/messagequeue.h"
+
+#include "freqscannersink.h"
+
+class DownChannelizer;
+class ChannelAPI;
+class FreqScanner;
+
+class FreqScannerBaseband : public QObject
+{
+    Q_OBJECT
+public:
+    class MsgConfigureFreqScannerBaseband : public Message {
+        MESSAGE_CLASS_DECLARATION
+
+    public:
+        const FreqScannerSettings& getSettings() const { return m_settings; }
+        const QStringList& getSettingsKeys() const { return m_settingsKeys; }
+        bool getForce() const { return m_force; }
+
+        static MsgConfigureFreqScannerBaseband* create(const FreqScannerSettings& settings, const QStringList& settingsKeys, bool force)
+        {
+            return new MsgConfigureFreqScannerBaseband(settings, settingsKeys, force);
+        }
+
+    private:
+        FreqScannerSettings m_settings;
+        QStringList m_settingsKeys;
+        bool m_force;
+
+        MsgConfigureFreqScannerBaseband(const FreqScannerSettings& settings, const QStringList& settingsKeys, bool force) :
+            Message(),
+            m_settings(settings),
+            m_settingsKeys(settingsKeys),
+            m_force(force)
+        { }
+    };
+
+    FreqScannerBaseband(FreqScanner *packetDemod);
+    ~FreqScannerBaseband();
+    void reset();
+    void startWork();
+    void stopWork();
+    void feed(const SampleVector::const_iterator& begin, const SampleVector::const_iterator& end);
+    MessageQueue *getInputMessageQueue() { return &m_inputMessageQueue; } //!< Get the queue for asynchronous inbound communication
+    void setMessageQueueToChannel(MessageQueue *messageQueue) { m_sink.setMessageQueueToChannel(messageQueue); }
+    void setMessageQueueToGUI(MessageQueue* messageQueue) { m_messageQueueToGUI = messageQueue; }
+    void setBasebandSampleRate(int sampleRate);
+    int getChannelSampleRate() const;
+    void setChannel(ChannelAPI *channel);
+    bool isRunning() const { return m_running; }
+    void setFifoLabel(const QString& label) { m_sampleFifo.setLabel(label); }
+
+private:
+    SampleSinkFifo m_sampleFifo;
+    DownChannelizer *m_channelizer;
+    int m_channelSampleRate;
+    int m_scannerSampleRate;
+    FreqScannerSink m_sink;
+    MessageQueue m_inputMessageQueue; //!< Queue for asynchronous inbound communication
+    MessageQueue *m_messageQueueToGUI;
+    FreqScannerSettings m_settings;
+    bool m_running;
+    QRecursiveMutex m_mutex;
+
+    bool handleMessage(const Message& cmd);
+    void applySettings(const FreqScannerSettings& settings, const QStringList& settingsKeys, bool force = false);
+    void calcScannerSampleRate(int basebandSampleRate, float rfBandwidth, int inputFrequencyOffset);
+    MessageQueue* getMessageQueueToGUI() { return m_messageQueueToGUI; }
+
+private slots:
+    void handleInputMessages();
+    void handleData(); //!< Handle data when samples have to be processed
+};
+
+#endif // INCLUDE_FREQSCANNERBASEBAND_H
diff --git a/plugins/channelrx/freqscanner/freqscannergui.cpp b/plugins/channelrx/freqscanner/freqscannergui.cpp
new file mode 100644
index 000000000..50f46a0b8
--- /dev/null
+++ b/plugins/channelrx/freqscanner/freqscannergui.cpp
@@ -0,0 +1,911 @@
+///////////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2016 Edouard Griffiths, F4EXB                                   //
+// Copyright (C) 2023 Jon Beniston, M7RCE                                        //
+//                                                                               //
+// This program is free software; you can redistribute it and/or modify          //
+// it under the terms of the GNU General Public License as published by          //
+// the Free Software Foundation as version 3 of the License, or                  //
+// (at your option) any later version.                                           //
+//                                                                               //
+// This program is distributed in the hope that it will be useful,               //
+// but WITHOUT ANY WARRANTY; without even the implied warranty of                //
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                  //
+// GNU General Public License V3 for more details.                               //
+//                                                                               //
+// You should have received a copy of the GNU General Public License             //
+// along with this program. If not, see <http://www.gnu.org/licenses/>.          //
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <QDebug>
+#include <QAction>
+#include <QClipboard>
+#include <QMenu>
+#include <QTableWidget>
+#include <QTableWidgetItem>
+
+#include "device/deviceset.h"
+#include "device/deviceuiset.h"
+#include "dsp/dspengine.h"
+#include "dsp/dspcommands.h"
+#include "ui_freqscannergui.h"
+#include "util/simpleserializer.h"
+#include "util/db.h"
+#include "gui/basicchannelsettingsdialog.h"
+#include "dsp/dspengine.h"
+#include "dsp/glscopesettings.h"
+#include "gui/tabletapandhold.h"
+#include "gui/dialogpositioner.h"
+#include "gui/decimaldelegate.h"
+#include "gui/frequencydelegate.h"
+#include "gui/glspectrum.h"
+#include "channel/channelwebapiutils.h"
+
+#include "freqscannergui.h"
+#include "freqscanneraddrangedialog.h"
+#include "freqscanner.h"
+#include "freqscannersink.h"
+
+FreqScannerGUI* FreqScannerGUI::create(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, BasebandSampleSink *rxChannel)
+{
+    FreqScannerGUI* gui = new FreqScannerGUI(pluginAPI, deviceUISet, rxChannel);
+    return gui;
+}
+
+void FreqScannerGUI::destroy()
+{
+    delete this;
+}
+
+void FreqScannerGUI::resetToDefaults()
+{
+    m_settings.resetToDefaults();
+    displaySettings();
+    applyAllSettings();
+}
+
+QByteArray FreqScannerGUI::serialize() const
+{
+    return m_settings.serialize();
+}
+
+bool FreqScannerGUI::deserialize(const QByteArray& data)
+{
+    if(m_settings.deserialize(data))
+    {
+        displaySettings();
+        applyAllSettings();
+        return true;
+    }
+    else
+    {
+        resetToDefaults();
+        return false;
+    }
+}
+
+bool FreqScannerGUI::handleMessage(const Message& message)
+{
+    if (FreqScanner::MsgConfigureFreqScanner::match(message))
+    {
+        qDebug("FreqScannerGUI::handleMessage: FreqScanner::MsgConfigureFreqScanner");
+        const FreqScanner::MsgConfigureFreqScanner& cfg = (FreqScanner::MsgConfigureFreqScanner&) message;
+        m_settings = cfg.getSettings();
+        blockApplySettings(true);
+        m_channelMarker.updateSettings(static_cast<const ChannelMarker*>(m_settings.m_channelMarker));
+        displaySettings();
+        blockApplySettings(false);
+        return true;
+    }
+    else if (DSPSignalNotification::match(message))
+    {
+        DSPSignalNotification& notif = (DSPSignalNotification&) message;
+        m_deviceCenterFrequency = notif.getCenterFrequency();
+        m_basebandSampleRate = notif.getSampleRate();
+        ui->deltaFrequency->setValueRange(true, 7, 0, m_basebandSampleRate/2);
+        ui->deltaFrequencyLabel->setToolTip(tr("Range %1 %L2 Hz").arg(QChar(0xB1)).arg(m_basebandSampleRate/2));
+        ui->channelBandwidth->setValueRange(true, 7, 8, m_basebandSampleRate);
+        if (m_channelMarker.getBandwidth() == 0) {
+            m_channelMarker.setBandwidth(m_basebandSampleRate);
+        }
+        updateAbsoluteCenterFrequency();
+        return true;
+    }
+    else if (FreqScanner::MsgReportChannels::match(message))
+    {
+        FreqScanner::MsgReportChannels& report = (FreqScanner::MsgReportChannels&)message;
+        updateChannelsList(report.getChannels());
+        return true;
+    }
+    else if (FreqScanner::MsgStatus::match(message))
+    {
+        FreqScanner::MsgStatus& report = (FreqScanner::MsgStatus&)message;
+        ui->status->setText(report.getText());
+        return true;
+    }
+    else if (FreqScanner::MsgReportScanning::match(message))
+    {
+        ui->status->setText("Scanning");
+        ui->table->clearSelection();
+        ui->channelPower->setText("-");
+        return true;
+    }
+    else if (FreqScanner::MsgScanComplete::match(message))
+    {
+        ui->startStop->setChecked(false);
+        return true;
+    }
+    else if (FreqScanner::MsgReportActiveFrequency::match(message))
+    {
+        FreqScanner::MsgReportActiveFrequency& report = (FreqScanner::MsgReportActiveFrequency&)message;
+        qint64 f = report.getCenterFrequency();
+        QString frequency;
+        QString annotation;
+        QList<QTableWidgetItem*> items = ui->table->findItems(QString::number(f), Qt::MatchExactly);
+        if (items.size() > 0)
+        {
+            ui->table->selectRow(items[0]->row());
+            frequency = ui->table->item(items[0]->row(), COL_FREQUENCY)->text();
+            annotation = ui->table->item(items[0]->row(), COL_ANNOTATION)->text();
+        }
+        FrequencyDelegate freqDelegate("Auto", 3);
+        QString formattedFrequency = freqDelegate.displayText(frequency, QLocale::system());
+        ui->status->setText(QString("Active: %1 %2").arg(formattedFrequency).arg(annotation));
+        return true;
+    }
+    else if (FreqScanner::MsgReportActivePower::match(message))
+    {
+        FreqScanner::MsgReportActivePower& report = (FreqScanner::MsgReportActivePower&)message;
+        float power = report.getPower();
+        ui->channelPower->setText(QString::number(power, 'f', 1));
+        return true;
+    }
+    else if (FreqScanner::MsgReportScanRange::match(message))
+    {
+        FreqScanner::MsgReportScanRange& report = (FreqScanner::MsgReportScanRange&)message;
+        m_channelMarker.setCenterFrequency(report.getCenterFrequency());
+        m_channelMarker.setBandwidth(report.getTotalBandwidth());
+        return true;
+    }
+    else if (FreqScanner::MsgScanResult::match(message))
+    {
+        FreqScanner::MsgScanResult& report = (FreqScanner::MsgScanResult&)message;
+        QList<FreqScanner::MsgScanResult::ScanResult> results = report.getScanResults();
+
+        // Clear column
+        for (int i = 0; i < ui->table->rowCount(); i++)
+        {
+            QTableWidgetItem* item = ui->table->item(i, COL_POWER);
+            item->setText("");
+            item->setBackground(QBrush());
+        }
+        // Add results
+        for (int i = 0; i < results.size(); i++)
+        {
+            qint64 freq = results[i].m_frequency;
+            QList<QTableWidgetItem *> items = ui->table->findItems(QString::number(freq), Qt::MatchExactly);
+            for (auto item : items) {
+                int row = item->row();
+                QTableWidgetItem* item = ui->table->item(row, COL_POWER);
+                item->setData(Qt::DisplayRole, results[i].m_power);
+                bool active = results[i].m_power >= m_settings.m_threshold;
+                if (active)
+                {
+                    item->setBackground(Qt::darkGreen);
+                    QTableWidgetItem* activeCountItem = ui->table->item(row, COL_ACTIVE_COUNT);
+                    activeCountItem->setData(Qt::DisplayRole, activeCountItem->data(Qt::DisplayRole).toInt() + 1);
+                }
+            }
+        }
+
+        return true;
+    }
+    return false;
+}
+
+void FreqScannerGUI::updateChannelsList(const QList<FreqScannerSettings::AvailableChannel>& channels)
+{
+    ui->channels->blockSignals(true);
+    ui->channels->clear();
+
+    for (const auto& channel : channels)
+    {
+        // Add channels in this device set, other than ourself
+        if ((channel.m_deviceSetIndex == getDeviceSetIndex()) && (channel.m_channelIndex != getIndex()))
+        {
+            QString name = QString("R%1:%2").arg(channel.m_deviceSetIndex).arg(channel.m_channelIndex);
+            ui->channels->addItem(name);
+        }
+    }
+
+    // Channel can be created after this plugin, so select it
+    // if the chosen channel appears
+    int channelIndex = ui->channels->findText(m_settings.m_channel);
+
+    if (channelIndex >= 0) {
+        ui->channels->setCurrentIndex(channelIndex);
+    } else {
+        ui->channels->setCurrentIndex(-1); // return to nothing selected
+    }
+
+    ui->channels->blockSignals(false);
+}
+
+void FreqScannerGUI::on_channels_currentIndexChanged(int index)
+{
+    if (index >= 0)
+    {
+        m_settings.m_channel = ui->channels->currentText();
+        applySetting("channel");
+    }
+}
+
+void FreqScannerGUI::handleInputMessages()
+{
+    Message* message;
+
+    while ((message = getInputMessageQueue()->pop()) != 0)
+    {
+        if (handleMessage(*message)) {
+            delete message;
+        }
+    }
+}
+
+void FreqScannerGUI::channelMarkerChangedByCursor()
+{
+}
+
+void FreqScannerGUI::channelMarkerHighlightedByCursor()
+{
+    setHighlighted(m_channelMarker.getHighlighted());
+}
+
+void FreqScannerGUI::on_deltaFrequency_changed(qint64 value)
+{
+    m_settings.m_channelFrequencyOffset = value;
+    applySetting("channelFrequencyOffset");
+}
+
+void FreqScannerGUI::on_channelBandwidth_changed(qint64 value)
+{
+    m_settings.m_channelBandwidth = value;
+    applySetting("channelBandwidth");
+}
+
+void FreqScannerGUI::on_scanTime_valueChanged(int value)
+{
+    ui->scanTimeText->setText(QString("%1 s").arg(value / 10.0, 0, 'f', 1));
+    m_settings.m_scanTime = value / 10.0;
+    applySetting("scanTime");
+}
+
+void FreqScannerGUI::on_retransmitTime_valueChanged(int value)
+{
+    ui->retransmitTimeText->setText(QString("%1 s").arg(value / 10.0, 0, 'f', 1));
+    m_settings.m_retransmitTime = value / 10.0;
+    applySetting("retransmitTime");
+}
+
+void FreqScannerGUI::on_tuneTime_valueChanged(int value)
+{
+    ui->tuneTimeText->setText(QString("%1 ms").arg(value));
+    m_settings.m_tuneTime = value;
+    applySetting("tuneTime");
+}
+
+void FreqScannerGUI::on_thresh_valueChanged(int value)
+{
+    ui->threshText->setText(QString("%1 dB").arg(value / 10.0, 0, 'f', 1));
+    m_settings.m_threshold = value / 10.0;
+    applySetting("threshold");
+}
+
+void FreqScannerGUI::on_priority_currentIndexChanged(int index)
+{
+    m_settings.m_priority = (FreqScannerSettings::Priority)index;
+    applySetting("priority");
+}
+
+void FreqScannerGUI::on_measurement_currentIndexChanged(int index)
+{
+    m_settings.m_measurement = (FreqScannerSettings::Measurement)index;
+    applySetting("measurement");
+}
+
+void FreqScannerGUI::on_mode_currentIndexChanged(int index)
+{
+    m_settings.m_mode = (FreqScannerSettings::Mode)index;
+    applySetting("mode");
+}
+
+void FreqScannerGUI::onWidgetRolled(QWidget* widget, bool rollDown)
+{
+    (void) widget;
+    (void) rollDown;
+
+    getRollupContents()->saveState(m_rollupState);
+    applySetting("rollupState");
+}
+
+void FreqScannerGUI::onMenuDialogCalled(const QPoint &p)
+{
+    if (m_contextMenuType == ContextMenuChannelSettings)
+    {
+        BasicChannelSettingsDialog dialog(&m_channelMarker, this);
+        dialog.setUseReverseAPI(m_settings.m_useReverseAPI);
+        dialog.setReverseAPIAddress(m_settings.m_reverseAPIAddress);
+        dialog.setReverseAPIPort(m_settings.m_reverseAPIPort);
+        dialog.setReverseAPIDeviceIndex(m_settings.m_reverseAPIDeviceIndex);
+        dialog.setReverseAPIChannelIndex(m_settings.m_reverseAPIChannelIndex);
+        dialog.setDefaultTitle(m_displayedName);
+
+        if (m_deviceUISet->m_deviceMIMOEngine)
+        {
+            dialog.setNumberOfStreams(m_freqScanner->getNumberOfDeviceStreams());
+            dialog.setStreamIndex(m_settings.m_streamIndex);
+        }
+
+        dialog.move(p);
+        new DialogPositioner(&dialog, false);
+        dialog.exec();
+
+        m_settings.m_rgbColor = m_channelMarker.getColor().rgb();
+        m_settings.m_title = m_channelMarker.getTitle();
+        m_settings.m_useReverseAPI = dialog.useReverseAPI();
+        m_settings.m_reverseAPIAddress = dialog.getReverseAPIAddress();
+        m_settings.m_reverseAPIPort = dialog.getReverseAPIPort();
+        m_settings.m_reverseAPIDeviceIndex = dialog.getReverseAPIDeviceIndex();
+        m_settings.m_reverseAPIChannelIndex = dialog.getReverseAPIChannelIndex();
+
+        setWindowTitle(m_settings.m_title);
+        setTitle(m_channelMarker.getTitle());
+        setTitleColor(m_settings.m_rgbColor);
+
+        QList<QString> settingsKeys({
+            "m_rgbColor",
+            "title",
+            "useReverseAPI",
+            "reverseAPIAddress",
+            "reverseAPIPort",
+            "reverseAPIDeviceIndex",
+            "reverseAPIChannelIndex"
+        });
+
+        if (m_deviceUISet->m_deviceMIMOEngine)
+        {
+            m_settings.m_streamIndex = dialog.getSelectedStreamIndex();
+            m_channelMarker.clearStreamIndexes();
+            m_channelMarker.addStreamIndex(m_settings.m_streamIndex);
+            updateIndexLabel();
+        }
+
+        applySettings(settingsKeys);
+    }
+
+    resetContextMenuType();
+}
+
+FreqScannerGUI::FreqScannerGUI(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, BasebandSampleSink *rxChannel, QWidget* parent) :
+    ChannelGUI(parent),
+    ui(new Ui::FreqScannerGUI),
+    m_pluginAPI(pluginAPI),
+    m_deviceUISet(deviceUISet),
+    m_channelMarker(this),
+    m_deviceCenterFrequency(0),
+    m_doApplySettings(true)
+{
+    setAttribute(Qt::WA_DeleteOnClose, true);
+    m_helpURL = "plugins/channelrx/freqscanner/readme.md";
+    RollupContents *rollupContents = getRollupContents();
+    ui->setupUi(rollupContents);
+    setSizePolicy(rollupContents->sizePolicy());
+    rollupContents->arrangeRollups();
+    connect(rollupContents, SIGNAL(widgetRolled(QWidget*,bool)), this, SLOT(onWidgetRolled(QWidget*,bool)));
+    connect(this, SIGNAL(customContextMenuRequested(const QPoint &)), this, SLOT(onMenuDialogCalled(const QPoint &)));
+
+    m_freqScanner = reinterpret_cast<FreqScanner*>(rxChannel);
+    m_freqScanner->setMessageQueueToGUI(getInputMessageQueue());
+
+    ui->deltaFrequencyLabel->setText(QString("%1f").arg(QChar(0x94, 0x03)));
+    ui->deltaFrequency->setColorMapper(ColorMapper(ColorMapper::GrayGold));
+    ui->deltaFrequency->setValueRange(true, 7, 0, 9999999);
+
+    ui->channelBandwidth->setColorMapper(ColorMapper(ColorMapper::GrayGreenYellow));
+    ui->channelBandwidth->setValueRange(true, 7, 16, 9999999);
+
+    m_channelMarker.setColor(Qt::yellow);
+    m_channelMarker.setCenterFrequency(m_settings.m_inputFrequencyOffset);
+    m_channelMarker.setTitle("Frequency Scanner");
+    m_channelMarker.blockSignals(false);
+    m_channelMarker.setVisible(true); // activate signal on the last setting only
+
+    setTitleColor(m_channelMarker.getColor());
+    m_settings.setChannelMarker(&m_channelMarker);
+    m_settings.setRollupState(&m_rollupState);
+
+    m_deviceUISet->addChannelMarker(&m_channelMarker);
+
+    connect(&m_channelMarker, SIGNAL(changedByCursor()), this, SLOT(channelMarkerChangedByCursor()));
+    connect(&m_channelMarker, SIGNAL(highlightedByCursor()), this, SLOT(channelMarkerHighlightedByCursor()));
+    connect(getInputMessageQueue(), SIGNAL(messageEnqueued()), this, SLOT(handleInputMessages()));
+
+    // Resize the table using dummy data
+    resizeTable();
+    // Allow user to reorder columns
+    ui->table->horizontalHeader()->setSectionsMovable(true);
+    // Add context menu to allow hiding/showing of columns
+    m_menu = new QMenu(ui->table);
+    for (int i = 0; i < ui->table->horizontalHeader()->count(); i++)
+    {
+        QString text = ui->table->horizontalHeaderItem(i)->text();
+        m_menu->addAction(createCheckableItem(text, i, true));
+    }
+    ui->table->horizontalHeader()->setContextMenuPolicy(Qt::CustomContextMenu);
+    connect(ui->table->horizontalHeader(), SIGNAL(customContextMenuRequested(QPoint)), SLOT(columnSelectMenu(QPoint)));
+    // Get signals when columns change
+    connect(ui->table->horizontalHeader(), SIGNAL(sectionMoved(int, int, int)), SLOT(table_sectionMoved(int, int, int)));
+    connect(ui->table->horizontalHeader(), SIGNAL(sectionResized(int, int, int)), SLOT(table_sectionResized(int, int, int)));
+    // Context menu
+    ui->table->setContextMenuPolicy(Qt::CustomContextMenu);
+    connect(ui->table, &QTableWidget::customContextMenuRequested, this, &FreqScannerGUI::table_customContextMenuRequested);
+    TableTapAndHold* tableTapAndHold = new TableTapAndHold(ui->table);
+    connect(tableTapAndHold, &TableTapAndHold::tapAndHold, this, &FreqScannerGUI::table_customContextMenuRequested);
+
+    ui->startStop->setStyleSheet(QString("QToolButton{ background-color: blue; } QToolButton:checked{ background-color: green; }"));
+
+    displaySettings();
+    makeUIConnections();
+    applyAllSettings();
+
+    ui->table->setItemDelegateForColumn(COL_FREQUENCY, new FrequencyDelegate("Auto", 3));
+    ui->table->setItemDelegateForColumn(COL_POWER, new DecimalDelegate(1));
+}
+
+FreqScannerGUI::~FreqScannerGUI()
+{
+    delete ui;
+}
+
+void FreqScannerGUI::blockApplySettings(bool block)
+{
+    m_doApplySettings = !block;
+}
+
+void FreqScannerGUI::applySetting(const QString& settingsKey)
+{
+    applySettings({settingsKey});
+}
+
+void FreqScannerGUI::applySettings(const QStringList& settingsKeys, bool force)
+{
+    if (m_doApplySettings)
+    {
+        FreqScanner::MsgConfigureFreqScanner* message = FreqScanner::MsgConfigureFreqScanner::create(m_settings, settingsKeys, force);
+        m_freqScanner->getInputMessageQueue()->push(message);
+    }
+}
+
+void FreqScannerGUI::applyAllSettings()
+{
+    applySettings(QStringList(), true);
+}
+
+void FreqScannerGUI::displaySettings()
+{
+    m_channelMarker.blockSignals(true);
+    m_channelMarker.setBandwidth(m_basebandSampleRate);
+    m_channelMarker.setCenterFrequency(m_settings.m_inputFrequencyOffset);
+    m_channelMarker.setTitle(m_settings.m_title);
+    m_channelMarker.blockSignals(false);
+    m_channelMarker.setColor(m_settings.m_rgbColor); // activate signal on the last setting only
+
+    setTitleColor(m_settings.m_rgbColor);
+    setWindowTitle(m_channelMarker.getTitle());
+    setTitle(m_channelMarker.getTitle());
+
+    blockApplySettings(true);
+
+    ui->deltaFrequency->setValue(m_settings.m_channelFrequencyOffset);
+    ui->channelBandwidth->setValue(m_settings.m_channelBandwidth);
+    ui->scanTime->setValue(m_settings.m_scanTime * 10.0);
+    ui->scanTimeText->setText(QString("%1 s").arg(m_settings.m_scanTime, 0, 'f', 1));
+    ui->retransmitTime->setValue(m_settings.m_retransmitTime * 10.0);
+    ui->retransmitTimeText->setText(QString("%1 s").arg(m_settings.m_retransmitTime, 0, 'f', 1));
+    ui->tuneTime->setValue(m_settings.m_tuneTime);
+    ui->tuneTimeText->setText(QString("%1 ms").arg(m_settings.m_tuneTime));
+    ui->thresh->setValue(m_settings.m_threshold * 10.0);
+    ui->threshText->setText(QString("%1 dB").arg(m_settings.m_threshold, 0, 'f', 1));
+    ui->priority->setCurrentIndex((int)m_settings.m_priority);
+    ui->measurement->setCurrentIndex((int)m_settings.m_measurement);
+    ui->mode->setCurrentIndex((int)m_settings.m_mode);
+
+    for (int i = 0; i < m_settings.m_frequencies.size(); i++) {
+        addRow(m_settings.m_frequencies[i], m_settings.m_enabled[i], m_settings.m_notes[i]);
+    }
+
+    // Order and size columns
+    QHeaderView* header = ui->table->horizontalHeader();
+    for (int i = 0; i < m_settings.m_columnSizes.size(); i++)
+    {
+        bool hidden = m_settings.m_columnSizes[i] == 0;
+        header->setSectionHidden(i, hidden);
+        m_menu->actions().at(i)->setChecked(!hidden);
+        if (m_settings.m_columnSizes[i] > 0) {
+            ui->table->setColumnWidth(i, m_settings.m_columnSizes[i]);
+        }
+        header->moveSection(header->visualIndex(i), m_settings.m_columnIndexes[i]);
+    }
+
+    updateIndexLabel();
+
+    getRollupContents()->restoreState(m_rollupState);
+    updateAbsoluteCenterFrequency();
+    blockApplySettings(false);
+}
+
+void FreqScannerGUI::leaveEvent(QEvent* event)
+{
+    m_channelMarker.setHighlighted(false);
+    ChannelGUI::leaveEvent(event);
+}
+
+void FreqScannerGUI::enterEvent(EnterEventType* event)
+{
+    m_channelMarker.setHighlighted(true);
+    ChannelGUI::enterEvent(event);
+}
+
+void FreqScannerGUI::on_startStop_clicked(bool checked)
+{
+    if (checked)
+    {
+        FreqScanner::MsgStartScan* message = FreqScanner::MsgStartScan::create();
+        m_freqScanner->getInputMessageQueue()->push(message);
+    }
+    else
+    {
+        FreqScanner::MsgStopScan* message = FreqScanner::MsgStopScan::create();
+        m_freqScanner->getInputMessageQueue()->push(message);
+    }
+}
+
+void FreqScannerGUI::addRow(qint64 frequency, bool enabled, const QString& notes)
+{
+    int row = ui->table->rowCount();
+    ui->table->setRowCount(row + 1);
+
+    // Must create before frequency so updateAnnotation can work
+    QTableWidgetItem* annotationItem = new QTableWidgetItem();
+    annotationItem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
+    ui->table->setItem(row, COL_ANNOTATION, annotationItem);
+
+    ui->table->setItem(row, COL_FREQUENCY, new QTableWidgetItem(QString("%1").arg(frequency)));
+
+    QTableWidgetItem *enableItem = new QTableWidgetItem();
+    enableItem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled);
+    enableItem->setCheckState(enabled ? Qt::Checked : Qt::Unchecked);
+    ui->table->setItem(row, COL_ENABLE, enableItem);
+
+    QTableWidgetItem* powerItem = new QTableWidgetItem();
+    powerItem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
+    ui->table->setItem(row, COL_POWER, powerItem);
+
+    QTableWidgetItem *activeCountItem = new QTableWidgetItem();
+    activeCountItem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
+    ui->table->setItem(row, COL_ACTIVE_COUNT, activeCountItem);
+    activeCountItem->setData(Qt::DisplayRole, 0);
+
+    QTableWidgetItem* notesItem = new QTableWidgetItem(notes);
+    ui->table->setItem(row, COL_NOTES, notesItem);
+}
+
+void FreqScannerGUI::on_addSingle_clicked()
+{
+    addRow(0, true);
+}
+
+void FreqScannerGUI::on_addRange_clicked()
+{
+    FreqScannerAddRangeDialog dialog(this);
+    new DialogPositioner(&dialog, false);
+    if (dialog.exec())
+    {
+        qint64 start = dialog.m_start;
+        qint64 stop = dialog.m_stop;
+        int step = dialog.m_step;
+
+        if ((start <= stop) && (step > 0))
+        {
+            for (qint64 f = start; f <= stop; f += step) {
+                addRow(f, true);
+            }
+        }
+    }
+}
+
+void FreqScannerGUI::on_remove_clicked()
+{
+    QList<QTableWidgetItem*> items = ui->table->selectedItems();
+
+    for (auto item : items)
+    {
+        int row = ui->table->row(item);
+        ui->table->removeRow(row);
+        m_settings.m_frequencies.removeAt(row); // table_cellChanged isn't called for removeRow
+        m_settings.m_enabled.removeAt(row);
+    }
+}
+
+static QList<QTableWidgetItem*> takeRow(QTableWidget* table, int row)
+{
+    QList<QTableWidgetItem*> rowItems;
+
+    for (int col = 0; col < table->columnCount(); col++) {
+        rowItems.append(table->takeItem(row, col));
+    }
+    return rowItems;
+}
+
+static void setRow(QTableWidget* table, int row, const QList<QTableWidgetItem*>& rowItems)
+{
+    for (int col = 0; col < rowItems.size(); col++) {
+        table->setItem(row, col, rowItems.at(col));
+    }
+}
+
+void FreqScannerGUI::on_up_clicked()
+{
+    QList<QTableWidgetItem*> items = ui->table->selectedItems();
+    for (auto item : items)
+    {
+        int row = ui->table->row(item);
+        if (row > 0)
+        {
+            QList<QTableWidgetItem*> sourceItems = takeRow(ui->table, row);
+            QList<QTableWidgetItem*> destItems = takeRow(ui->table, row - 1);
+            setRow(ui->table, row - 1, sourceItems);
+            setRow(ui->table, row, destItems);
+            ui->table->setCurrentCell(row - 1, 0);
+        }
+    }
+}
+
+void FreqScannerGUI::on_down_clicked()
+{
+    QList<QTableWidgetItem*> items = ui->table->selectedItems();
+    for (auto item : items)
+    {
+        int row = ui->table->row(item);
+        if (row < ui->table->rowCount() - 1)
+        {
+            QList<QTableWidgetItem*> sourceItems = takeRow(ui->table, row);
+            QList<QTableWidgetItem*> destItems = takeRow(ui->table, row + 1);
+            setRow(ui->table, row + 1, sourceItems);
+            setRow(ui->table, row, destItems);
+            ui->table->setCurrentCell(row + 1, 0);
+        }
+    }
+}
+
+void FreqScannerGUI::on_table_cellChanged(int row, int column)
+{
+    QTableWidgetItem* item = ui->table->item(row, column);
+    if (item)
+    {
+        if (column == COL_FREQUENCY)
+        {
+            qint64 value = item->text().toLongLong();
+            while (m_settings.m_frequencies.size() <= row)
+            {
+                m_settings.m_frequencies.append(0);
+                m_settings.m_enabled.append(true);
+                m_settings.m_notes.append("");
+            }
+            m_settings.m_frequencies[row] = value;
+            updateAnnotation(row);
+            QList<QString> settingsKeys({
+                 "frequencies",
+                 "enabled",
+                 "notes"
+                });
+            applySettings(settingsKeys);
+        }
+        else if (column == COL_ENABLE)
+        {
+            m_settings.m_enabled[row] = item->checkState() == Qt::Checked;
+            applySetting("enabled");
+        }
+        else if (column == COL_NOTES)
+        {
+            m_settings.m_notes[row] = item->text();
+            applySetting("notes");
+        }
+    }
+}
+
+void FreqScannerGUI::updateAnnotation(int row)
+{
+    QTableWidgetItem* item = ui->table->item(row, COL_FREQUENCY);
+    QTableWidgetItem* annotationItem = ui->table->item(row, COL_ANNOTATION);
+    if (item && annotationItem)
+    {
+        qint64 frequency = item->text().toLongLong();
+        const QList<SpectrumAnnotationMarker>& markers = m_deviceUISet->m_spectrum->getAnnotationMarkers();
+        const SpectrumAnnotationMarker* closest = nullptr;
+        for (const auto& marker : markers)
+        {
+            if ((marker.m_startFrequency <= frequency) && (frequency < marker.m_startFrequency + marker.m_bandwidth))
+            {
+                if (marker.m_bandwidth == m_settings.m_channelBandwidth) {
+                    // Exact match
+                    annotationItem->setText(marker.m_text);
+                    return;
+                } else if (!closest) {
+                    closest = &marker;
+                } else {
+                    if (marker.m_bandwidth < closest->m_bandwidth) {
+                        closest = &marker;
+                    }
+                }
+            }
+        }
+        if (closest) {
+            annotationItem->setText(closest->m_text);
+        }
+    }
+}
+
+void FreqScannerGUI::table_customContextMenuRequested(QPoint pos)
+{
+    QTableWidgetItem* item = ui->table->itemAt(pos);
+    if (item)
+    {
+        int row = item->row();
+
+        QMenu* tableContextMenu = new QMenu(ui->table);
+        connect(tableContextMenu, &QMenu::aboutToHide, tableContextMenu, &QMenu::deleteLater);
+
+        // Copy current cell
+
+        QAction* copyAction = new QAction("Copy", tableContextMenu);
+        const QString text = item->text();
+        connect(copyAction, &QAction::triggered, this, [text]()->void {
+            QClipboard* clipboard = QGuiApplication::clipboard();
+            clipboard->setText(text);
+            });
+        tableContextMenu->addAction(copyAction);
+
+        tableContextMenu->addSeparator();
+
+        // Tune to frequency
+
+        const QRegExp re("R([0-9]+):([0-9]+)");
+        if (re.indexIn(m_settings.m_channel) >= 0)
+        {
+            int scanDeviceSetIndex = re.capturedTexts()[1].toInt();
+            int scanChannelIndex = re.capturedTexts()[2].toInt();
+            qDebug() << "scanDeviceSetIndex" << scanDeviceSetIndex << "scanChannelIndex" << scanChannelIndex;
+
+            qint64 frequency = ui->table->item(row, COL_FREQUENCY)->text().toLongLong();
+
+            QAction* findChannelMapAction = new QAction(QString("Tune R%1:%2 to %3").arg(scanDeviceSetIndex).arg(scanChannelIndex).arg(frequency), tableContextMenu);
+            connect(findChannelMapAction, &QAction::triggered, this, [this, scanDeviceSetIndex, scanChannelIndex, frequency]()->void {
+
+                if ((frequency - m_settings.m_channelBandwidth / 2 < m_deviceCenterFrequency - m_basebandSampleRate / 2)
+                    || (frequency + m_settings.m_channelBandwidth / 2 >= m_deviceCenterFrequency + m_basebandSampleRate / 2))
+                {
+                    qint64 centerFrequency = frequency;
+                    int offset = 0;
+                    while (frequency - centerFrequency < m_settings.m_channelFrequencyOffset)
+                    {
+                        centerFrequency -= m_settings.m_channelBandwidth;
+                        offset += m_settings.m_channelBandwidth;
+                    }
+
+                    if (!ChannelWebAPIUtils::setCenterFrequency(getDeviceSetIndex(), centerFrequency)) {
+                        qWarning() << "Scanner failed to set frequency" << centerFrequency;
+                    }
+
+                    ChannelWebAPIUtils::setFrequencyOffset(scanDeviceSetIndex, scanChannelIndex, offset);
+                }
+                else
+                {
+                    int offset = frequency - m_deviceCenterFrequency;
+                    ChannelWebAPIUtils::setFrequencyOffset(scanDeviceSetIndex, scanChannelIndex, offset);
+                }
+
+                });
+            tableContextMenu->addAction(findChannelMapAction);
+        }
+        else
+        {
+            qDebug() << "Failed to parse channel" << m_settings.m_channel;
+        }
+
+        tableContextMenu->popup(ui->table->viewport()->mapToGlobal(pos));
+    }
+}
+
+// Columns in table reordered
+void FreqScannerGUI::table_sectionMoved(int logicalIndex, int oldVisualIndex, int newVisualIndex)
+{
+    (void)oldVisualIndex;
+    m_settings.m_columnIndexes[logicalIndex] = newVisualIndex;
+}
+
+// Column in table resized (when hidden size is 0)
+void FreqScannerGUI::table_sectionResized(int logicalIndex, int oldSize, int newSize)
+{
+    (void)oldSize;
+    m_settings.m_columnSizes[logicalIndex] = newSize;
+}
+
+// Right click in ADSB table header - show column select menu
+void FreqScannerGUI::columnSelectMenu(QPoint pos)
+{
+    m_menu->popup(ui->table->horizontalHeader()->viewport()->mapToGlobal(pos));
+}
+
+// Hide/show column when menu selected
+void FreqScannerGUI::columnSelectMenuChecked(bool checked)
+{
+    (void)checked;
+    QAction* action = qobject_cast<QAction*>(sender());
+    if (action != nullptr)
+    {
+        int idx = action->data().toInt(nullptr);
+        ui->table->setColumnHidden(idx, !action->isChecked());
+    }
+}
+
+// Create column select menu item
+QAction* FreqScannerGUI::createCheckableItem(QString& text, int idx, bool checked)
+{
+    QAction* action = new QAction(text, this);
+    action->setCheckable(true);
+    action->setChecked(checked);
+    action->setData(QVariant(idx));
+    connect(action, SIGNAL(triggered()), this, SLOT(columnSelectMenuChecked()));
+    return action;
+}
+
+void FreqScannerGUI::resizeTable()
+{
+    // Fill table with a row of dummy data that will size the columns nicely
+    int row = ui->table->rowCount();
+    ui->table->setRowCount(row + 1);
+    ui->table->setItem(row, COL_FREQUENCY, new QTableWidgetItem("999.000 MHz"));
+    ui->table->setItem(row, COL_ANNOTATION, new QTableWidgetItem("An annotation"));
+    ui->table->setItem(row, COL_ENABLE, new QTableWidgetItem("Enable"));
+    ui->table->setItem(row, COL_POWER, new QTableWidgetItem("-100.0"));
+    ui->table->setItem(row, COL_ACTIVE_COUNT, new QTableWidgetItem("10000"));
+    ui->table->setItem(row, COL_NOTES, new QTableWidgetItem("Enter some notes"));
+    ui->table->resizeColumnsToContents();
+    ui->table->setRowCount(row);
+}
+
+void FreqScannerGUI::makeUIConnections()
+{
+    QObject::connect(ui->channels, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &FreqScannerGUI::on_channels_currentIndexChanged);
+    QObject::connect(ui->deltaFrequency, &ValueDialZ::changed, this, &FreqScannerGUI::on_deltaFrequency_changed);
+    QObject::connect(ui->channelBandwidth, &ValueDialZ::changed, this, &FreqScannerGUI::on_channelBandwidth_changed);
+    QObject::connect(ui->scanTime, &QDial::valueChanged, this, &FreqScannerGUI::on_scanTime_valueChanged);
+    QObject::connect(ui->retransmitTime, &QDial::valueChanged, this, &FreqScannerGUI::on_retransmitTime_valueChanged);
+    QObject::connect(ui->tuneTime, &QDial::valueChanged, this, &FreqScannerGUI::on_tuneTime_valueChanged);
+    QObject::connect(ui->thresh, &QDial::valueChanged, this, &FreqScannerGUI::on_thresh_valueChanged);
+    QObject::connect(ui->priority, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &FreqScannerGUI::on_priority_currentIndexChanged);
+    QObject::connect(ui->measurement, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &FreqScannerGUI::on_measurement_currentIndexChanged);
+    QObject::connect(ui->mode, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &FreqScannerGUI::on_mode_currentIndexChanged);
+    QObject::connect(ui->startStop, &ButtonSwitch::clicked, this, &FreqScannerGUI::on_startStop_clicked);
+    QObject::connect(ui->table, &QTableWidget::cellChanged, this, &FreqScannerGUI::on_table_cellChanged);
+    QObject::connect(ui->addSingle, &QToolButton::clicked, this, &FreqScannerGUI::on_addSingle_clicked);
+    QObject::connect(ui->addRange, &QToolButton::clicked, this, &FreqScannerGUI::on_addRange_clicked);
+    QObject::connect(ui->remove, &QToolButton::clicked, this, &FreqScannerGUI::on_remove_clicked);
+    QObject::connect(ui->up, &QToolButton::clicked, this, &FreqScannerGUI::on_up_clicked);
+    QObject::connect(ui->down, &QToolButton::clicked, this, &FreqScannerGUI::on_down_clicked);
+}
+
+void FreqScannerGUI::updateAbsoluteCenterFrequency()
+{
+    setStatusFrequency(m_deviceCenterFrequency + m_settings.m_inputFrequencyOffset);
+}
diff --git a/plugins/channelrx/freqscanner/freqscannergui.h b/plugins/channelrx/freqscanner/freqscannergui.h
new file mode 100644
index 000000000..ef95ee212
--- /dev/null
+++ b/plugins/channelrx/freqscanner/freqscannergui.h
@@ -0,0 +1,142 @@
+///////////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2016 Edouard Griffiths, F4EXB                                   //
+// Copyright (C) 2023 Jon Beniston, M7RCE                                        //
+//                                                                               //
+// This program is free software; you can redistribute it and/or modify          //
+// it under the terms of the GNU General Public License as published by          //
+// the Free Software Foundation as version 3 of the License, or                  //
+// (at your option) any later version.                                           //
+//                                                                               //
+// This program is distributed in the hope that it will be useful,               //
+// but WITHOUT ANY WARRANTY; without even the implied warranty of                //
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                  //
+// GNU General Public License V3 for more details.                               //
+//                                                                               //
+// You should have received a copy of the GNU General Public License             //
+// along with this program. If not, see <http://www.gnu.org/licenses/>.          //
+///////////////////////////////////////////////////////////////////////////////////
+
+#ifndef INCLUDE_FREQSCANNERGUI_H
+#define INCLUDE_FREQSCANNERGUI_H
+
+#include "channel/channelgui.h"
+#include "dsp/channelmarker.h"
+#include "util/messagequeue.h"
+#include "settings/rollupstate.h"
+#include "freqscanner.h"
+#include "freqscannersettings.h"
+
+class PluginAPI;
+class DeviceUISet;
+class BasebandSampleSink;
+class FreqScanner;
+class FreqScannerGUI;
+class QMenu;
+
+namespace Ui {
+    class FreqScannerGUI;
+}
+class FreqScannerGUI;
+
+class FreqScannerGUI : public ChannelGUI {
+    Q_OBJECT
+
+public:
+    static FreqScannerGUI* create(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, BasebandSampleSink *rxChannel);
+    virtual void destroy();
+
+    void resetToDefaults();
+    QByteArray serialize() const;
+    bool deserialize(const QByteArray& data);
+    virtual MessageQueue *getInputMessageQueue() { return &m_inputMessageQueue; }
+    virtual void setWorkspaceIndex(int index) { m_settings.m_workspaceIndex = index; };
+    virtual int getWorkspaceIndex() const { return m_settings.m_workspaceIndex; };
+    virtual void setGeometryBytes(const QByteArray& blob) { m_settings.m_geometryBytes = blob; };
+    virtual QByteArray getGeometryBytes() const { return m_settings.m_geometryBytes; };
+    virtual QString getTitle() const { return m_settings.m_title; };
+    virtual QColor getTitleColor() const  { return m_settings.m_rgbColor; };
+    virtual void zetHidden(bool hidden) { m_settings.m_hidden = hidden; }
+    virtual bool getHidden() const { return m_settings.m_hidden; }
+    virtual ChannelMarker& getChannelMarker() { return m_channelMarker; }
+    virtual int getStreamIndex() const { return m_settings.m_streamIndex; }
+    virtual void setStreamIndex(int streamIndex) { m_settings.m_streamIndex = streamIndex; }
+
+public slots:
+    void channelMarkerChangedByCursor();
+    void channelMarkerHighlightedByCursor();
+
+private:
+    Ui::FreqScannerGUI* ui;
+    PluginAPI* m_pluginAPI;
+    DeviceUISet* m_deviceUISet;
+    ChannelMarker m_channelMarker;
+    RollupState m_rollupState;
+    FreqScannerSettings m_settings;
+    qint64 m_deviceCenterFrequency;
+    bool m_doApplySettings;
+
+    FreqScanner* m_freqScanner;
+    int m_basebandSampleRate;
+    MessageQueue m_inputMessageQueue;
+
+    QMenu *m_menu;
+
+    explicit FreqScannerGUI(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, BasebandSampleSink *rxChannel, QWidget* parent = 0);
+    virtual ~FreqScannerGUI();
+
+    void blockApplySettings(bool block);
+    void applySetting(const QString& settingsKey);
+    void applySettings(const QStringList& settingsKeys, bool force = false);
+    void applyAllSettings();
+    void displaySettings();
+    bool handleMessage(const Message& message);
+    void makeUIConnections();
+    void updateAbsoluteCenterFrequency();
+    void addRow(qint64 frequency, bool enabled, const QString& notes = "");
+    void updateAnnotation(int row);
+    void updateChannelsList(const QList<FreqScannerSettings::AvailableChannel>& channels);
+
+    void leaveEvent(QEvent*);
+    void enterEvent(EnterEventType*);
+
+    void resizeTable();
+    QAction* createCheckableItem(QString& text, int idx, bool checked);
+
+    enum Col {
+        COL_FREQUENCY,
+        COL_ANNOTATION,
+        COL_ENABLE,
+        COL_POWER,
+        COL_ACTIVE_COUNT,
+        COL_NOTES
+    };
+
+private slots:
+    void on_channels_currentIndexChanged(int index);
+    void on_deltaFrequency_changed(qint64 value);
+    void on_channelBandwidth_changed(qint64 index);
+    void on_scanTime_valueChanged(int value);
+    void on_retransmitTime_valueChanged(int value);
+    void on_tuneTime_valueChanged(int value);
+    void on_thresh_valueChanged(int value);
+    void on_priority_currentIndexChanged(int index);
+    void on_measurement_currentIndexChanged(int index);
+    void on_mode_currentIndexChanged(int index);
+    void on_table_cellChanged(int row, int column);
+    void table_customContextMenuRequested(QPoint pos);
+    void table_sectionMoved(int logicalIndex, int oldVisualIndex, int newVisualIndex);
+    void table_sectionResized(int logicalIndex, int oldSize, int newSize);
+    void columnSelectMenu(QPoint pos);
+    void columnSelectMenuChecked(bool checked = false);
+    void on_startStop_clicked(bool checked = false);
+    void on_addSingle_clicked();
+    void on_addRange_clicked();
+    void on_remove_clicked();
+    void on_up_clicked();
+    void on_down_clicked();
+    void onWidgetRolled(QWidget* widget, bool rollDown);
+    void onMenuDialogCalled(const QPoint& p);
+    void handleInputMessages();
+};
+
+#endif // INCLUDE_FREQSCANNERGUI_H
diff --git a/plugins/channelrx/freqscanner/freqscannergui.ui b/plugins/channelrx/freqscanner/freqscannergui.ui
new file mode 100644
index 000000000..d00ed10e7
--- /dev/null
+++ b/plugins/channelrx/freqscanner/freqscannergui.ui
@@ -0,0 +1,776 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>FreqScannerGUI</class>
+ <widget class="RollupContents" name="FreqScannerGUI">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>419</width>
+    <height>431</height>
+   </rect>
+  </property>
+  <property name="sizePolicy">
+   <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+    <horstretch>0</horstretch>
+    <verstretch>0</verstretch>
+   </sizepolicy>
+  </property>
+  <property name="minimumSize">
+   <size>
+    <width>400</width>
+    <height>0</height>
+   </size>
+  </property>
+  <property name="font">
+   <font>
+    <family>Liberation Sans</family>
+    <pointsize>9</pointsize>
+   </font>
+  </property>
+  <property name="focusPolicy">
+   <enum>Qt::StrongFocus</enum>
+  </property>
+  <property name="windowTitle">
+   <string>Frequency Scanner</string>
+  </property>
+  <widget class="QWidget" name="settingsContainer" native="true">
+   <property name="geometry">
+    <rect>
+     <x>0</x>
+     <y>0</y>
+     <width>411</width>
+     <height>411</height>
+    </rect>
+   </property>
+   <property name="sizePolicy">
+    <sizepolicy hsizetype="Preferred" vsizetype="Expanding">
+     <horstretch>0</horstretch>
+     <verstretch>0</verstretch>
+    </sizepolicy>
+   </property>
+   <property name="minimumSize">
+    <size>
+     <width>350</width>
+     <height>0</height>
+    </size>
+   </property>
+   <property name="windowTitle">
+    <string>Settings</string>
+   </property>
+   <layout class="QVBoxLayout" name="verticalLayout">
+    <property name="spacing">
+     <number>3</number>
+    </property>
+    <property name="leftMargin">
+     <number>2</number>
+    </property>
+    <property name="topMargin">
+     <number>2</number>
+    </property>
+    <property name="rightMargin">
+     <number>2</number>
+    </property>
+    <property name="bottomMargin">
+     <number>2</number>
+    </property>
+    <item>
+     <layout class="QHBoxLayout" name="powLayout">
+      <property name="topMargin">
+       <number>2</number>
+      </property>
+      <item>
+       <widget class="QLabel" name="channelsLabel">
+        <property name="text">
+         <string>Channel</string>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="QComboBox" name="channels">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="toolTip">
+         <string>Channel to tune</string>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="Line" name="line_6">
+        <property name="orientation">
+         <enum>Qt::Vertical</enum>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="QLabel" name="deltaFrequencyLabel">
+        <property name="minimumSize">
+         <size>
+          <width>16</width>
+          <height>0</height>
+         </size>
+        </property>
+        <property name="text">
+         <string>Df</string>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="ValueDialZ" name="deltaFrequency" native="true">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Maximum" vsizetype="Maximum">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="minimumSize">
+         <size>
+          <width>32</width>
+          <height>16</height>
+         </size>
+        </property>
+        <property name="font">
+         <font>
+          <family>Liberation Mono</family>
+          <pointsize>12</pointsize>
+         </font>
+        </property>
+        <property name="cursor">
+         <cursorShape>PointingHandCursor</cursorShape>
+        </property>
+        <property name="focusPolicy">
+         <enum>Qt::StrongFocus</enum>
+        </property>
+        <property name="toolTip">
+         <string>Minimum demod shift frequency from center in Hz</string>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="QLabel" name="deltaUnits">
+        <property name="text">
+         <string>Hz </string>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="Line" name="line">
+        <property name="orientation">
+         <enum>Qt::Vertical</enum>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <spacer name="horizontalSpacer">
+        <property name="orientation">
+         <enum>Qt::Horizontal</enum>
+        </property>
+        <property name="sizeHint" stdset="0">
+         <size>
+          <width>40</width>
+          <height>20</height>
+         </size>
+        </property>
+       </spacer>
+      </item>
+      <item>
+       <layout class="QHBoxLayout" name="channelPowerLayout">
+        <item>
+         <widget class="QLabel" name="channelPower">
+          <property name="toolTip">
+           <string>Active frequency power </string>
+          </property>
+          <property name="layoutDirection">
+           <enum>Qt::RightToLeft</enum>
+          </property>
+          <property name="text">
+           <string>-</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QLabel" name="channelPowerUnits">
+          <property name="text">
+           <string> dB</string>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </item>
+     </layout>
+    </item>
+    <item>
+     <widget class="Line" name="line_7">
+      <property name="orientation">
+       <enum>Qt::Horizontal</enum>
+      </property>
+     </widget>
+    </item>
+    <item>
+     <layout class="QHBoxLayout" name="powerLayout">
+      <item>
+       <widget class="QLabel" name="threshLabel">
+        <property name="text">
+         <string>TH</string>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="QDial" name="thresh">
+        <property name="maximumSize">
+         <size>
+          <width>24</width>
+          <height>24</height>
+         </size>
+        </property>
+        <property name="toolTip">
+         <string>Power threshold in dB</string>
+        </property>
+        <property name="minimum">
+         <number>-1400</number>
+        </property>
+        <property name="maximum">
+         <number>100</number>
+        </property>
+        <property name="pageStep">
+         <number>1</number>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="QLabel" name="threshText">
+        <property name="minimumSize">
+         <size>
+          <width>55</width>
+          <height>0</height>
+         </size>
+        </property>
+        <property name="text">
+         <string>-100.0 dB</string>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <spacer name="horizontalSpacer_3">
+        <property name="orientation">
+         <enum>Qt::Horizontal</enum>
+        </property>
+        <property name="sizeHint" stdset="0">
+         <size>
+          <width>40</width>
+          <height>20</height>
+         </size>
+        </property>
+       </spacer>
+      </item>
+      <item>
+       <widget class="Line" name="line_4">
+        <property name="orientation">
+         <enum>Qt::Vertical</enum>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="QLabel" name="tuneTimeLabel">
+        <property name="text">
+         <string>t&lt;sub&gt;Δf&lt;/sub&gt;</string>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="QDial" name="tuneTime">
+        <property name="maximumSize">
+         <size>
+          <width>24</width>
+          <height>24</height>
+         </size>
+        </property>
+        <property name="toolTip">
+         <string>Time in milliseconds to wait before starting measurement after changing frequency</string>
+        </property>
+        <property name="minimum">
+         <number>0</number>
+        </property>
+        <property name="maximum">
+         <number>1000</number>
+        </property>
+        <property name="pageStep">
+         <number>1</number>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="QLabel" name="tuneTimeText">
+        <property name="minimumSize">
+         <size>
+          <width>45</width>
+          <height>0</height>
+         </size>
+        </property>
+        <property name="text">
+         <string>100 ms</string>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="Line" name="line_3">
+        <property name="orientation">
+         <enum>Qt::Vertical</enum>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="QLabel" name="scanTimeLabel">
+        <property name="text">
+         <string>t&lt;sub&gt;S&lt;/sub&gt;</string>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="QDial" name="scanTime">
+        <property name="maximumSize">
+         <size>
+          <width>24</width>
+          <height>24</height>
+         </size>
+        </property>
+        <property name="toolTip">
+         <string>Scan power measurement time in seconds</string>
+        </property>
+        <property name="minimum">
+         <number>1</number>
+        </property>
+        <property name="maximum">
+         <number>100</number>
+        </property>
+        <property name="pageStep">
+         <number>1</number>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="QLabel" name="scanTimeText">
+        <property name="minimumSize">
+         <size>
+          <width>35</width>
+          <height>0</height>
+         </size>
+        </property>
+        <property name="text">
+         <string>10.0 s</string>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="Line" name="line_2">
+        <property name="orientation">
+         <enum>Qt::Vertical</enum>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="QLabel" name="retransmitTimeLabel">
+        <property name="text">
+         <string>t&lt;sub&gt;RTX&lt;/sub&gt;</string>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="QDial" name="retransmitTime">
+        <property name="maximumSize">
+         <size>
+          <width>24</width>
+          <height>24</height>
+         </size>
+        </property>
+        <property name="toolTip">
+         <string>Time in seconds to wait for frequency to become active again, before restarting scan</string>
+        </property>
+        <property name="minimum">
+         <number>0</number>
+        </property>
+        <property name="maximum">
+         <number>100</number>
+        </property>
+        <property name="pageStep">
+         <number>1</number>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="QLabel" name="retransmitTimeText">
+        <property name="minimumSize">
+         <size>
+          <width>35</width>
+          <height>0</height>
+         </size>
+        </property>
+        <property name="text">
+         <string>10.0 s</string>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </item>
+    <item>
+     <widget class="Line" name="line_5">
+      <property name="orientation">
+       <enum>Qt::Horizontal</enum>
+      </property>
+     </widget>
+    </item>
+    <item>
+     <layout class="QHBoxLayout" name="phySettingsLayout">
+      <item>
+       <widget class="QLabel" name="rfBWLabel">
+        <property name="text">
+         <string>Ch BW</string>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="ValueDialZ" name="channelBandwidth" native="true">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Maximum" vsizetype="Maximum">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="minimumSize">
+         <size>
+          <width>32</width>
+          <height>16</height>
+         </size>
+        </property>
+        <property name="font">
+         <font>
+          <family>Liberation Mono</family>
+          <pointsize>12</pointsize>
+         </font>
+        </property>
+        <property name="cursor">
+         <cursorShape>PointingHandCursor</cursorShape>
+        </property>
+        <property name="focusPolicy">
+         <enum>Qt::StrongFocus</enum>
+        </property>
+        <property name="toolTip">
+         <string>Channel bandwidth</string>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="QLabel" name="rfBWUnits">
+        <property name="text">
+         <string>Hz</string>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <spacer name="horizontalSpacer_4">
+        <property name="orientation">
+         <enum>Qt::Horizontal</enum>
+        </property>
+        <property name="sizeHint" stdset="0">
+         <size>
+          <width>40</width>
+          <height>20</height>
+         </size>
+        </property>
+       </spacer>
+      </item>
+      <item>
+       <widget class="QLabel" name="priorityLabel">
+        <property name="text">
+         <string>Pri</string>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="QComboBox" name="priority">
+        <property name="minimumSize">
+         <size>
+          <width>85</width>
+          <height>0</height>
+         </size>
+        </property>
+        <property name="toolTip">
+         <string>Prioritisation. Select frequency with highest power or first in table.</string>
+        </property>
+        <item>
+         <property name="text">
+          <string>Max Power</string>
+         </property>
+        </item>
+        <item>
+         <property name="text">
+          <string>Table Order</string>
+         </property>
+        </item>
+       </widget>
+      </item>
+      <item>
+       <widget class="QLabel" name="measurementLabel">
+        <property name="text">
+         <string>Meas</string>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="QComboBox" name="measurement">
+        <property name="toolTip">
+         <string>Whether the power measurement is the peak power within the channel or total channel power</string>
+        </property>
+        <item>
+         <property name="text">
+          <string>Peak</string>
+         </property>
+        </item>
+        <item>
+         <property name="text">
+          <string>Total</string>
+         </property>
+        </item>
+       </widget>
+      </item>
+     </layout>
+    </item>
+    <item>
+     <widget class="Line" name="filterLine">
+      <property name="orientation">
+       <enum>Qt::Horizontal</enum>
+      </property>
+     </widget>
+    </item>
+    <item>
+     <layout class="QHBoxLayout" name="toolbarLayout">
+      <item>
+       <widget class="QComboBox" name="mode">
+        <property name="minimumSize">
+         <size>
+          <width>90</width>
+          <height>0</height>
+         </size>
+        </property>
+        <property name="toolTip">
+         <string>Run mode</string>
+        </property>
+        <property name="currentIndex">
+         <number>1</number>
+        </property>
+        <item>
+         <property name="text">
+          <string>Single</string>
+         </property>
+        </item>
+        <item>
+         <property name="text">
+          <string>Continuous</string>
+         </property>
+        </item>
+        <item>
+         <property name="text">
+          <string>Scan-only</string>
+         </property>
+        </item>
+       </widget>
+      </item>
+      <item>
+       <widget class="ButtonSwitch" name="startStop">
+        <property name="toolTip">
+         <string>Start/stop frequency scanning</string>
+        </property>
+        <property name="text">
+         <string/>
+        </property>
+        <property name="icon">
+         <iconset resource="../../../sdrgui/resources/res.qrc">
+          <normaloff>:/play.png</normaloff>
+          <normalon>:/stop.png</normalon>:/play.png</iconset>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="QLabel" name="status">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="text">
+         <string/>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </item>
+    <item>
+     <widget class="Line" name="line_8">
+      <property name="orientation">
+       <enum>Qt::Horizontal</enum>
+      </property>
+     </widget>
+    </item>
+    <item>
+     <layout class="QVBoxLayout" name="verticalLayout_2">
+      <item>
+       <widget class="QTableWidget" name="table">
+        <column>
+         <property name="text">
+          <string>Freq (Hz)</string>
+         </property>
+         <property name="toolTip">
+          <string>Center frequency in Hertz of the channel</string>
+         </property>
+        </column>
+        <column>
+         <property name="text">
+          <string>Annotation</string>
+         </property>
+        </column>
+        <column>
+         <property name="text">
+          <string>Enable</string>
+         </property>
+         <property name="toolTip">
+          <string>Whether the channel is enabled</string>
+         </property>
+        </column>
+        <column>
+         <property name="text">
+          <string>Power (dB)</string>
+         </property>
+         <property name="toolTip">
+          <string>Channel power in decibels during the previous scan</string>
+         </property>
+        </column>
+        <column>
+         <property name="text">
+          <string>Active Count</string>
+         </property>
+         <property name="toolTip">
+          <string>Count of the number of times the channel is active when scanned</string>
+         </property>
+        </column>
+        <column>
+         <property name="text">
+          <string>Notes</string>
+         </property>
+         <property name="toolTip">
+          <string>User notes about this frequency</string>
+         </property>
+        </column>
+       </widget>
+      </item>
+      <item>
+       <layout class="QHBoxLayout" name="horizontalLayout">
+        <item>
+         <widget class="QToolButton" name="addSingle">
+          <property name="toolTip">
+           <string>Add a single frequency</string>
+          </property>
+          <property name="text">
+           <string>Add</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QToolButton" name="addRange">
+          <property name="toolTip">
+           <string>Add a range of frequencies</string>
+          </property>
+          <property name="text">
+           <string>Add Range</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QToolButton" name="remove">
+          <property name="toolTip">
+           <string>Remove selected items</string>
+          </property>
+          <property name="text">
+           <string>Remove</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QToolButton" name="up">
+          <property name="toolTip">
+           <string>Move selected rows up</string>
+          </property>
+          <property name="text">
+           <string>Up</string>
+          </property>
+          <property name="icon">
+           <iconset resource="../../../sdrgui/resources/res.qrc">
+            <normaloff>:/arrow_up.png</normaloff>:/arrow_up.png</iconset>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QToolButton" name="down">
+          <property name="toolTip">
+           <string>Move selected rows down</string>
+          </property>
+          <property name="text">
+           <string/>
+          </property>
+          <property name="icon">
+           <iconset resource="../../../sdrgui/resources/res.qrc">
+            <normaloff>:/arrow_down.png</normaloff>:/arrow_down.png</iconset>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <spacer name="horizontalSpacer_2">
+          <property name="orientation">
+           <enum>Qt::Horizontal</enum>
+          </property>
+          <property name="sizeHint" stdset="0">
+           <size>
+            <width>40</width>
+            <height>20</height>
+           </size>
+          </property>
+         </spacer>
+        </item>
+       </layout>
+      </item>
+     </layout>
+    </item>
+   </layout>
+  </widget>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>ButtonSwitch</class>
+   <extends>QToolButton</extends>
+   <header>gui/buttonswitch.h</header>
+  </customwidget>
+  <customwidget>
+   <class>RollupContents</class>
+   <extends>QWidget</extends>
+   <header>gui/rollupcontents.h</header>
+   <container>1</container>
+  </customwidget>
+  <customwidget>
+   <class>ValueDialZ</class>
+   <extends>QWidget</extends>
+   <header>gui/valuedialz.h</header>
+   <container>1</container>
+  </customwidget>
+ </customwidgets>
+ <tabstops>
+  <tabstop>deltaFrequency</tabstop>
+ </tabstops>
+ <resources>
+  <include location="../../../sdrgui/resources/res.qrc"/>
+ </resources>
+ <connections/>
+</ui>
diff --git a/plugins/channelrx/freqscanner/freqscannerplugin.cpp b/plugins/channelrx/freqscanner/freqscannerplugin.cpp
new file mode 100644
index 000000000..37012c7eb
--- /dev/null
+++ b/plugins/channelrx/freqscanner/freqscannerplugin.cpp
@@ -0,0 +1,93 @@
+///////////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2016 Edouard Griffiths, F4EXB                                   //
+// Copyright (C) 2023 Jon Beniston, M7RCE                                        //
+//                                                                               //
+// This program is free software; you can redistribute it and/or modify          //
+// it under the terms of the GNU General Public License as published by          //
+// the Free Software Foundation as version 3 of the License, or                  //
+// (at your option) any later version.                                           //
+//                                                                               //
+// This program is distributed in the hope that it will be useful,               //
+// but WITHOUT ANY WARRANTY; without even the implied warranty of                //
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                  //
+// GNU General Public License V3 for more details.                               //
+//                                                                               //
+// You should have received a copy of the GNU General Public License             //
+// along with this program. If not, see <http://www.gnu.org/licenses/>.          //
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <QtPlugin>
+#include "plugin/pluginapi.h"
+
+#ifndef SERVER_MODE
+#include "freqscannergui.h"
+#endif
+#include "freqscanner.h"
+#include "freqscannerwebapiadapter.h"
+#include "freqscannerplugin.h"
+
+const PluginDescriptor FreqScannerPlugin::m_pluginDescriptor = {
+    FreqScanner::m_channelId,
+    QStringLiteral("Frequency Scanner"),
+    QStringLiteral("7.17.0"),
+    QStringLiteral("(c) Jon Beniston, M7RCE"),
+    QStringLiteral("https://github.com/f4exb/sdrangel"),
+    true,
+    QStringLiteral("https://github.com/f4exb/sdrangel")
+};
+
+FreqScannerPlugin::FreqScannerPlugin(QObject* parent) :
+    QObject(parent),
+    m_pluginAPI(0)
+{
+}
+
+const PluginDescriptor& FreqScannerPlugin::getPluginDescriptor() const
+{
+    return m_pluginDescriptor;
+}
+
+void FreqScannerPlugin::initPlugin(PluginAPI* pluginAPI)
+{
+    m_pluginAPI = pluginAPI;
+
+    m_pluginAPI->registerRxChannel(FreqScanner::m_channelIdURI, FreqScanner::m_channelId, this);
+}
+
+void FreqScannerPlugin::createRxChannel(DeviceAPI *deviceAPI, BasebandSampleSink **bs, ChannelAPI **cs) const
+{
+    if (bs || cs)
+    {
+        FreqScanner *instance = new FreqScanner(deviceAPI);
+
+        if (bs) {
+            *bs = instance;
+        }
+
+        if (cs) {
+            *cs = instance;
+        }
+    }
+}
+
+#ifdef SERVER_MODE
+ChannelGUI* FreqScannerPlugin::createRxChannelGUI(
+        DeviceUISet *deviceUISet,
+        BasebandSampleSink *rxChannel) const
+{
+    (void) deviceUISet;
+    (void) rxChannel;
+    return 0;
+}
+#else
+ChannelGUI* FreqScannerPlugin::createRxChannelGUI(DeviceUISet *deviceUISet, BasebandSampleSink *rxChannel) const
+{
+    return FreqScannerGUI::create(m_pluginAPI, deviceUISet, rxChannel);
+}
+#endif
+
+ChannelWebAPIAdapter* FreqScannerPlugin::createChannelWebAPIAdapter() const
+{
+    return new FreqScannerWebAPIAdapter();
+}
+
diff --git a/plugins/channelrx/freqscanner/freqscannerplugin.h b/plugins/channelrx/freqscanner/freqscannerplugin.h
new file mode 100644
index 000000000..403352b4c
--- /dev/null
+++ b/plugins/channelrx/freqscanner/freqscannerplugin.h
@@ -0,0 +1,50 @@
+///////////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2016 Edouard Griffiths, F4EXB                                   //
+// Copyright (C) 2023 Jon Beniston, M7RCE                                        //
+//                                                                               //
+// This program is free software; you can redistribute it and/or modify          //
+// it under the terms of the GNU General Public License as published by          //
+// the Free Software Foundation as version 3 of the License, or                  //
+// (at your option) any later version.                                           //
+//                                                                               //
+// This program is distributed in the hope that it will be useful,               //
+// but WITHOUT ANY WARRANTY; without even the implied warranty of                //
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                  //
+// GNU General Public License V3 for more details.                               //
+//                                                                               //
+// You should have received a copy of the GNU General Public License             //
+// along with this program. If not, see <http://www.gnu.org/licenses/>.          //
+///////////////////////////////////////////////////////////////////////////////////
+
+#ifndef INCLUDE_FREQSCANNERPLUGIN_H
+#define INCLUDE_FREQSCANNERPLUGIN_H
+
+#include <QObject>
+#include "plugin/plugininterface.h"
+
+class DeviceUISet;
+class BasebandSampleSink;
+
+class FreqScannerPlugin : public QObject, PluginInterface {
+    Q_OBJECT
+    Q_INTERFACES(PluginInterface)
+    Q_PLUGIN_METADATA(IID "sdrangel.channel.freqscanner")
+
+public:
+    explicit FreqScannerPlugin(QObject* parent = NULL);
+
+    const PluginDescriptor& getPluginDescriptor() const;
+    void initPlugin(PluginAPI* pluginAPI);
+
+    virtual void createRxChannel(DeviceAPI *deviceAPI, BasebandSampleSink **bs, ChannelAPI **cs) const;
+    virtual ChannelGUI* createRxChannelGUI(DeviceUISet *deviceUISet, BasebandSampleSink *rxChannel) const;
+    virtual ChannelWebAPIAdapter* createChannelWebAPIAdapter() const;
+
+private:
+    static const PluginDescriptor m_pluginDescriptor;
+
+    PluginAPI* m_pluginAPI;
+};
+
+#endif // INCLUDE_FREQSCANNERPLUGIN_H
+
diff --git a/plugins/channelrx/freqscanner/freqscannersettings.cpp b/plugins/channelrx/freqscanner/freqscannersettings.cpp
new file mode 100644
index 000000000..d7ec2c6d9
--- /dev/null
+++ b/plugins/channelrx/freqscanner/freqscannersettings.cpp
@@ -0,0 +1,366 @@
+///////////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2015 Edouard Griffiths, F4EXB.                                  //
+// Copyright (C) 2023 Jon Beniston, M7RCE                                        //
+//                                                                               //
+// This program is free software; you can redistribute it and/or modify          //
+// it under the terms of the GNU General Public License as published by          //
+// the Free Software Foundation as version 3 of the License, or                  //
+// (at your option) any later version.                                           //
+//                                                                               //
+// This program is distributed in the hope that it will be useful,               //
+// but WITHOUT ANY WARRANTY; without even the implied warranty of                //
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                  //
+// GNU General Public License V3 for more details.                               //
+//                                                                               //
+// You should have received a copy of the GNU General Public License             //
+// along with this program. If not, see <http://www.gnu.org/licenses/>.          //
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <QColor>
+
+#include "util/simpleserializer.h"
+#include "settings/serializable.h"
+#include "freqscannersettings.h"
+
+FreqScannerSettings::FreqScannerSettings() :
+    m_channelMarker(nullptr),
+    m_rollupState(nullptr)
+{
+    for (int i = 0; i < FREQSCANNER_COLUMNS; i++)
+    {
+        m_columnIndexes.append(i);
+        m_columnSizes.append(-1);
+    }
+    resetToDefaults();
+}
+
+void FreqScannerSettings::resetToDefaults()
+{
+    m_inputFrequencyOffset = 0;
+    m_channelBandwidth = 25000;
+    m_channelFrequencyOffset = 25000;
+    m_threshold = -60.0f;
+    m_channel = "";
+    m_scanTime = 0.1f;
+    m_retransmitTime = 2.0f;
+    m_tuneTime = 100;
+    m_priority = MAX_POWER;
+    m_measurement = PEAK;
+    m_mode = CONTINUOUS;
+
+    for (int i = 0; i < FREQSCANNER_COLUMNS; i++)
+    {
+        m_columnIndexes[i] = i;
+        m_columnSizes[i] = -1; // Autosize
+    }
+
+    m_rgbColor = QColor(0, 205, 200).rgb();
+    m_title = "Frequency Scanner";
+    m_streamIndex = 0;
+    m_useReverseAPI = false;
+    m_reverseAPIAddress = "127.0.0.1";
+    m_reverseAPIPort = 8888;
+    m_reverseAPIDeviceIndex = 0;
+    m_reverseAPIChannelIndex = 0;
+    m_workspaceIndex = 0;
+    m_hidden = false;
+}
+
+QByteArray FreqScannerSettings::serialize() const
+{
+    SimpleSerializer s(1);
+
+    s.writeS32(1, m_inputFrequencyOffset);
+    s.writeS32(2, m_channelBandwidth);
+    s.writeS32(3, m_channelFrequencyOffset);
+    s.writeFloat(4, m_threshold);
+    s.writeList(5, m_notes);
+    s.writeList(6, m_enabled);
+    s.writeList(7, m_frequencies);
+    s.writeString(8, m_channel);
+    s.writeFloat(9, m_scanTime);
+    s.writeFloat(10, m_retransmitTime);
+    s.writeS32(11, m_tuneTime);
+    s.writeS32(12, (int)m_priority);
+    s.writeS32(13, (int)m_measurement);
+    s.writeS32(14, (int)m_mode);
+
+    s.writeList(20, m_columnIndexes);
+    s.writeList(21, m_columnSizes);
+
+    s.writeU32(40, m_rgbColor);
+    s.writeString(41, m_title);
+    if (m_channelMarker) {
+        s.writeBlob(42, m_channelMarker->serialize());
+    }
+    s.writeS32(44, m_streamIndex);
+    s.writeBool(45, m_useReverseAPI);
+    s.writeString(46, m_reverseAPIAddress);
+    s.writeU32(47, m_reverseAPIPort);
+    s.writeU32(48, m_reverseAPIDeviceIndex);
+    s.writeU32(49, m_reverseAPIChannelIndex);
+    if (m_rollupState) {
+        s.writeBlob(52, m_rollupState->serialize());
+    }
+    s.writeS32(53, m_workspaceIndex);
+    s.writeBlob(54, m_geometryBytes);
+    s.writeBool(55, m_hidden);
+
+    return s.final();
+}
+
+bool FreqScannerSettings::deserialize(const QByteArray& data)
+{
+    SimpleDeserializer d(data);
+
+    if(!d.isValid())
+    {
+        resetToDefaults();
+        return false;
+    }
+
+    if(d.getVersion() == 1)
+    {
+        QByteArray bytetmp;
+        uint32_t utmp;
+        QString strtmp;
+
+        d.readS32(1, &m_inputFrequencyOffset, 0);
+        d.readS32(2, &m_channelBandwidth, 25000);
+        d.readS32(3, &m_channelFrequencyOffset, 25000);
+        d.readFloat(4, &m_threshold, -60.0f);
+        d.readList(5, &m_notes);
+        d.readList(6, &m_enabled);
+        d.readList(7, &m_frequencies);
+        d.readString(8, &m_channel);
+        while (m_notes.size() < m_frequencies.size()) {
+            m_notes.append("");
+        }
+        while (m_enabled.size() < m_frequencies.size()) {
+            m_enabled.append(true);
+        }
+        d.readFloat(9, &m_scanTime, 0.1f);
+        d.readFloat(10, &m_retransmitTime, 2.0f);
+        d.readS32(11, &m_tuneTime, 100);
+        d.readS32(12, (int*)&m_priority, (int)MAX_POWER);
+        d.readS32(13, (int*)&m_measurement, (int)PEAK);
+        d.readS32(14, (int*)&m_mode, (int)CONTINUOUS);
+
+        d.readList(20, &m_columnIndexes);
+        d.readList(21, &m_columnSizes);
+
+        d.readU32(40, &m_rgbColor, QColor(0, 205, 200).rgb());
+        d.readString(41, &m_title, "Frequency Scanner");
+        if (m_channelMarker)
+        {
+            d.readBlob(42, &bytetmp);
+            m_channelMarker->deserialize(bytetmp);
+        }
+        d.readS32(44, &m_streamIndex, 0);
+        d.readBool(45, &m_useReverseAPI, false);
+        d.readString(46, &m_reverseAPIAddress, "127.0.0.1");
+        d.readU32(47, &utmp, 0);
+        if ((utmp > 1023) && (utmp < 65535)) {
+            m_reverseAPIPort = utmp;
+        } else {
+            m_reverseAPIPort = 8888;
+        }
+        d.readU32(48, &utmp, 0);
+        m_reverseAPIDeviceIndex = utmp > 99 ? 99 : utmp;
+        d.readU32(49, &utmp, 0);
+        m_reverseAPIChannelIndex = utmp > 99 ? 99 : utmp;
+        if (m_rollupState)
+        {
+            d.readBlob(52, &bytetmp);
+            m_rollupState->deserialize(bytetmp);
+        }
+        d.readS32(53, &m_workspaceIndex, 0);
+        d.readBlob(54, &m_geometryBytes);
+        d.readBool(55, &m_hidden, false);
+
+        return true;
+    }
+    else
+    {
+        resetToDefaults();
+        return false;
+    }
+}
+
+void FreqScannerSettings::applySettings(const QStringList& settingsKeys, const FreqScannerSettings& settings)
+{
+    if (settingsKeys.contains("inputFrequencyOffset")) {
+        m_inputFrequencyOffset = settings.m_inputFrequencyOffset;
+    }
+    if (settingsKeys.contains("channelBandwidth")) {
+        m_channelBandwidth = settings.m_channelBandwidth;
+    }
+    if (settingsKeys.contains("channelFrequencyOffset")) {
+        m_channelFrequencyOffset = settings.m_channelFrequencyOffset;
+    }
+    if (settingsKeys.contains("threshold")) {
+        m_threshold = settings.m_threshold;
+    }
+    if (settingsKeys.contains("frequencies")) {
+        m_frequencies = settings.m_frequencies;
+    }
+    if (settingsKeys.contains("enabled")) {
+        m_enabled = settings.m_enabled;
+    }
+    if (settingsKeys.contains("notes")) {
+        m_notes = settings.m_notes;
+    }
+    if (settingsKeys.contains("channel")) {
+        m_channel = settings.m_channel;
+    }
+    if (settingsKeys.contains("scanTime")) {
+        m_scanTime = settings.m_scanTime;
+    }
+    if (settingsKeys.contains("retransmitTime")) {
+        m_retransmitTime = settings.m_retransmitTime;
+    }
+    if (settingsKeys.contains("tuneTime")) {
+        m_tuneTime = settings.m_tuneTime;
+    }
+    if (settingsKeys.contains("priority")) {
+        m_priority = settings.m_priority;
+    }
+    if (settingsKeys.contains("measurement")) {
+        m_measurement = settings.m_measurement;
+    }
+    if (settingsKeys.contains("mode")) {
+        m_mode = settings.m_mode;
+    }
+    if (settingsKeys.contains("columnIndexes")) {
+        m_columnIndexes = settings.m_columnIndexes;
+    }
+    if (settingsKeys.contains("columnSizes")) {
+        m_columnSizes = settings.m_columnSizes;
+    }
+    if (settingsKeys.contains("rgbColor")) {
+        m_rgbColor = settings.m_rgbColor;
+    }
+    if (settingsKeys.contains("title")) {
+        m_title = settings.m_title;
+    }
+    if (settingsKeys.contains("streamIndex")) {
+        m_streamIndex = settings.m_streamIndex;
+    }
+    if (settingsKeys.contains("useReverseAPI")) {
+        m_useReverseAPI = settings.m_useReverseAPI;
+    }
+    if (settingsKeys.contains("reverseAPIAddress")) {
+        m_reverseAPIAddress = settings.m_reverseAPIAddress;
+    }
+    if (settingsKeys.contains("reverseAPIPort")) {
+        m_reverseAPIPort = settings.m_reverseAPIPort;
+    }
+    if (settingsKeys.contains("reverseAPIDeviceIndex")) {
+        m_reverseAPIDeviceIndex = settings.m_reverseAPIDeviceIndex;
+    }
+    if (settingsKeys.contains("reverseAPIChannelIndex")) {
+        m_reverseAPIChannelIndex = settings.m_reverseAPIChannelIndex;
+    }
+    if (settingsKeys.contains("workspaceIndex")) {
+        m_workspaceIndex = settings.m_workspaceIndex;
+    }
+    if (settingsKeys.contains("hidden")) {
+        m_hidden = settings.m_hidden;
+    }
+}
+
+QString FreqScannerSettings::getDebugString(const QStringList& settingsKeys, bool force) const
+{
+    std::ostringstream ostr;
+
+    if (settingsKeys.contains("inputFrequencyOffset") || force) {
+        ostr << " m_inputFrequencyOffset: " << m_inputFrequencyOffset;
+    }
+    if (settingsKeys.contains("channelBandwidth") || force) {
+        ostr << " m_channelBandwidth: " << m_channelBandwidth;
+    }
+    if (settingsKeys.contains("channelFrequencyOffset") || force) {
+        ostr << " m_channelFrequencyOffset: " << m_channelFrequencyOffset;
+    }
+    if (settingsKeys.contains("threshold") || force) {
+        ostr << " m_threshold: " << m_threshold;
+    }
+    if (settingsKeys.contains("frequencies") || force)
+    {
+        QStringList s;
+        for (auto f : m_frequencies) {
+            s.append(QString::number(f));
+        }
+        ostr << " m_frequencies: " << s.join(",").toStdString();
+    }
+    if (settingsKeys.contains("enabled") || force)
+    {
+        QStringList s;
+        for (auto e : m_enabled) {
+            s.append(e ? "true" : "false");
+        }
+        ostr << " m_enabled: " << s.join(",").toStdString();
+    }
+    if (settingsKeys.contains("notes") || force) {
+        ostr << " m_notes: " << m_notes.join(",").toStdString();
+    }
+    if (settingsKeys.contains("channel") || force) {
+        ostr << " m_channel: " << m_channel.toStdString();
+    }
+    if (settingsKeys.contains("scanTime") || force) {
+        ostr << " m_scanTime: " << m_scanTime;
+    }
+    if (settingsKeys.contains("retransmitTime") || force) {
+        ostr << " m_retransmitTime: " << m_retransmitTime;
+    }
+    if (settingsKeys.contains("tuneTime") || force) {
+        ostr << " m_tuneTime: " << m_tuneTime;
+    }
+    if (settingsKeys.contains("priority") || force) {
+        ostr << " m_priority: " << m_priority;
+    }
+    if (settingsKeys.contains("measurement") || force) {
+        ostr << " m_measurement: " << m_measurement;
+    }
+    if (settingsKeys.contains("mode") || force) {
+        ostr << " m_mode: " << m_mode;
+    }
+    if (settingsKeys.contains("columnIndexes") || force) {
+        // Don't display
+    }
+    if (settingsKeys.contains("columnSizes") || force) {
+        // Don't display
+    }
+    if (settingsKeys.contains("rgbColor") || force) {
+        ostr << " m_rgbColor: " << m_rgbColor;
+    }
+    if (settingsKeys.contains("title") || force) {
+        ostr << " m_title: " << m_title.toStdString();
+    }
+    if (settingsKeys.contains("streamIndex") || force) {
+        ostr << " m_streamIndex: " << m_streamIndex;
+    }
+    if (settingsKeys.contains("useReverseAPI") || force) {
+        ostr << " m_useReverseAPI: " << m_useReverseAPI;
+    }
+    if (settingsKeys.contains("reverseAPIAddress") || force) {
+        ostr << " m_reverseAPIAddress: " << m_reverseAPIAddress.toStdString();
+    }
+    if (settingsKeys.contains("reverseAPIPort") || force) {
+        ostr << " m_reverseAPIPort: " << m_reverseAPIPort;
+    }
+    if (settingsKeys.contains("reverseAPIDeviceIndex") || force) {
+        ostr << " m_reverseAPIDeviceIndex: " << m_reverseAPIDeviceIndex;
+    }
+    if (settingsKeys.contains("reverseAPIChannelIndex") || force) {
+        ostr << " m_reverseAPIChannelIndex: " << m_reverseAPIChannelIndex;
+    }
+    if (settingsKeys.contains("workspaceIndex") || force) {
+        ostr << " m_workspaceIndex: " << m_workspaceIndex;
+    }
+    if (settingsKeys.contains("hidden") || force) {
+        ostr << " m_hidden: " << m_hidden;
+    }
+
+    return QString(ostr.str().c_str());
+}
diff --git a/plugins/channelrx/freqscanner/freqscannersettings.h b/plugins/channelrx/freqscanner/freqscannersettings.h
new file mode 100644
index 000000000..f6dbd86e6
--- /dev/null
+++ b/plugins/channelrx/freqscanner/freqscannersettings.h
@@ -0,0 +1,96 @@
+///////////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2017 Edouard Griffiths, F4EXB.                                  //
+// Copyright (C) 2023 Jon Beniston, M7RCE                                        //
+//                                                                               //
+// This program is free software; you can redistribute it and/or modify          //
+// it under the terms of the GNU General Public License as published by          //
+// the Free Software Foundation as version 3 of the License, or                  //
+// (at your option) any later version.                                           //
+//                                                                               //
+// This program is distributed in the hope that it will be useful,               //
+// but WITHOUT ANY WARRANTY; without even the implied warranty of                //
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                  //
+// GNU General Public License V3 for more details.                               //
+//                                                                               //
+// You should have received a copy of the GNU General Public License             //
+// along with this program. If not, see <http://www.gnu.org/licenses/>.          //
+///////////////////////////////////////////////////////////////////////////////////
+
+#ifndef INCLUDE_FREQSCANNERSETTINGS_H
+#define INCLUDE_FREQSCANNERSETTINGS_H
+
+#include <QByteArray>
+
+class Serializable;
+class ChannelAPI;
+
+// Number of columns in the table
+#define FREQSCANNER_COLUMNS           6
+
+struct FreqScannerSettings
+{
+    struct AvailableChannel
+    {
+        int m_deviceSetIndex;
+        int m_channelIndex;
+        ChannelAPI* m_channelAPI;
+
+        AvailableChannel() = default;
+        AvailableChannel(const AvailableChannel&) = default;
+        AvailableChannel& operator=(const AvailableChannel&) = default;
+    };
+
+    qint32 m_inputFrequencyOffset;  //!< Not modifable in GUI
+    qint32 m_channelBandwidth;      //!< Channel bandwidth
+    qint32 m_channelFrequencyOffset;//!< Minium DC offset of tuned channel
+    Real m_threshold;               //!< Power threshold in dB
+    QList<qint64> m_frequencies;    //!< Frequencies to scan
+    QList<bool> m_enabled;          //!< Whether corresponding frequency is enabled
+    QList<QString> m_notes;         //!< User editable notes about this frequency
+    QString m_channel;              //!< Channel (E.g: R1:4) to tune to active frequency
+    float m_scanTime;               //!< In seconds
+    float m_retransmitTime;         //!< In seconds
+    int m_tuneTime;                 //!< In milliseconds
+    enum Priority {
+        MAX_POWER,
+        TABLE_ORDER
+    } m_priority;                   //!< Which frequency has priority when multiple frequencies are above threshold
+    enum Measurement {
+        PEAK,
+        TOTAL
+    } m_measurement;                //!< How power is measured
+    enum Mode {
+        SINGLE,
+        CONTINUOUS,
+        SCAN_ONLY
+    } m_mode;                       //!< Whether to run a single or many scans
+
+    QList<int> m_columnIndexes;//!< How the columns are ordered in the table
+    QList<int> m_columnSizes;  //!< Size of the coumns in the table
+
+    quint32 m_rgbColor;
+    QString m_title;
+    Serializable *m_channelMarker;
+    int m_streamIndex; //!< MIMO channel. Not relevant when connected to SI (single Rx).
+    bool m_useReverseAPI;
+    QString m_reverseAPIAddress;
+    uint16_t m_reverseAPIPort;
+    uint16_t m_reverseAPIDeviceIndex;
+    uint16_t m_reverseAPIChannelIndex;
+
+    Serializable *m_rollupState;
+    int m_workspaceIndex;
+    QByteArray m_geometryBytes;
+    bool m_hidden;
+
+    FreqScannerSettings();
+    void resetToDefaults();
+    void setChannelMarker(Serializable *channelMarker) { m_channelMarker = channelMarker; }
+    void setRollupState(Serializable *rollupState) { m_rollupState = rollupState; }
+    QByteArray serialize() const;
+    bool deserialize(const QByteArray& data);
+    void applySettings(const QStringList& settingsKeys, const FreqScannerSettings& settings);
+    QString getDebugString(const QStringList& settingsKeys, bool force = false) const;
+};
+
+#endif /* INCLUDE_FREQSCANNERSETTINGS_H */
diff --git a/plugins/channelrx/freqscanner/freqscannersink.cpp b/plugins/channelrx/freqscanner/freqscannersink.cpp
new file mode 100644
index 000000000..bc3625bed
--- /dev/null
+++ b/plugins/channelrx/freqscanner/freqscannersink.cpp
@@ -0,0 +1,253 @@
+///////////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2019 Edouard Griffiths, F4EXB                                   //
+// Copyright (C) 2023 Jon Beniston, M7RCE                                        //
+//                                                                               //
+// This program is free software; you can redistribute it and/or modify          //
+// it under the terms of the GNU General Public License as published by          //
+// the Free Software Foundation as version 3 of the License, or                  //
+// (at your option) any later version.                                           //
+//                                                                               //
+// This program is distributed in the hope that it will be useful,               //
+// but WITHOUT ANY WARRANTY; without even the implied warranty of                //
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                  //
+// GNU General Public License V3 for more details.                               //
+//                                                                               //
+// You should have received a copy of the GNU General Public License             //
+// along with this program. If not, see <http://www.gnu.org/licenses/>.          //
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <QDebug>
+
+#include <complex.h>
+
+#include "dsp/dspengine.h"
+#include "util/db.h"
+
+#include "freqscanner.h"
+#include "freqscannersink.h"
+
+FreqScannerSink::FreqScannerSink(FreqScanner *ilsDemod) :
+        m_freqScanner(ilsDemod),
+        m_channel(nullptr),
+        m_channelSampleRate(48000),
+        m_channelFrequencyOffset(0),
+        m_scannerSampleRate(33320),
+        m_centerFrequency(0),
+        m_messageQueueToChannel(nullptr),
+        m_fftSequence(-1),
+        m_fft(nullptr),
+        m_fftCounter(0)
+{
+    applySettings(m_settings, QStringList(), true);
+    applyChannelSettings(m_channelSampleRate, m_channelFrequencyOffset, 16, 4, true);
+}
+
+FreqScannerSink::~FreqScannerSink()
+{
+}
+
+void FreqScannerSink::feed(const SampleVector::const_iterator& begin, const SampleVector::const_iterator& end)
+{
+    Complex ci;
+
+    for (SampleVector::const_iterator it = begin; it != end; ++it)
+    {
+        Complex c(it->real(), it->imag());
+        c *= m_nco.nextIQ();
+
+        if (m_interpolatorDistance == 1.0f) // Don't call decimate, as we don't want filter applied if possible
+        {
+            processOneSample(c);
+        }
+        else if (m_interpolatorDistance < 1.0f) // interpolate
+        {
+            while (!m_interpolator.interpolate(&m_interpolatorDistanceRemain, c, &ci))
+            {
+                processOneSample(ci);
+                m_interpolatorDistanceRemain += m_interpolatorDistance;
+            }
+        }
+        else // decimate
+        {
+            if (m_interpolator.decimate(&m_interpolatorDistanceRemain, c, &ci))
+            {
+                processOneSample(ci);
+                m_interpolatorDistanceRemain += m_interpolatorDistance;
+            }
+        }
+    }
+}
+
+void FreqScannerSink::processOneSample(Complex &ci)
+{
+    ci /= SDR_RX_SCALEF;
+
+    m_fft->in()[m_fftCounter] = ci;
+    m_fftCounter++;
+    if (m_fftCounter == m_fftSize)
+    {
+        // Apply windowing function
+        m_fftWindow.apply(m_fft->in());
+
+        // Perform FFT
+        m_fft->transform();
+
+        // Reorder (so negative frequencies are first) and average
+        int halfSize = m_fftSize / 2;
+        for (int i = 0; i < halfSize; i++) {
+            m_fftAverage.storeAndGetAvg(m_magSq[i], magSq(i + halfSize), i);
+        }
+        for (int i = 0; i < halfSize; i++) {
+            m_fftAverage.storeAndGetAvg(m_magSq[i + halfSize], magSq(i), i + halfSize);
+        }
+
+        if (m_fftAverage.nextAverage())
+        {
+            // Send results to channel
+            if (getMessageQueueToChannel())
+            {
+                FreqScanner::MsgScanResult* msg = FreqScanner::MsgScanResult::create(m_fftStartTime);
+                QList<FreqScanner::MsgScanResult::ScanResult>& results = msg->getScanResults();
+
+                for (int i = 0; i < m_settings.m_frequencies.size(); i++)
+                {
+                    if (m_settings.m_enabled[i])
+                    {
+                        qint64 frequency = m_settings.m_frequencies[i];
+                        qint64 startFrequency = m_centerFrequency - m_scannerSampleRate / 2;
+                        qint64 diff = frequency - startFrequency;
+                        int binBW = m_settings.m_channelBandwidth / m_binsPerChannel;
+
+                        if ((diff < m_scannerSampleRate) && (diff >= 0))
+                        {
+                            int bin = diff / binBW;
+
+                            // Calculate power at that frequency
+                            Real power;
+                            if (m_settings.m_measurement == FreqScannerSettings::PEAK) {
+                                power = peakPower(bin);
+                            } else {
+                                power = totalPower(bin);
+                            }
+
+                            FreqScanner::MsgScanResult::ScanResult result = {frequency, power};
+                            results.append(result);
+                        }
+                    }
+                }
+                getMessageQueueToChannel()->push(msg);
+            }
+            m_averageCount = 0;
+            m_fftStartTime = QDateTime::currentDateTime();
+        }
+        m_fftCounter = 0;
+    }
+}
+
+// Calculate total power in a channel containing the specified bin (i.e. sums adjacent bins in the same channel)
+Real FreqScannerSink::totalPower(int bin) const
+{
+    // Skip bin between halfway between channels
+    // Then skip first and last bins, to avoid spectral leakage (particularly at DC)
+    int startBin = bin - m_binsPerChannel / 2 + 1 + 1;
+    Real magSqSum = 0.0f;
+    for (int i = 0; i < m_binsPerChannel - 2 - 1; i++) {
+        int idx = startBin + i;
+        if ((idx < 0) || (idx >= m_fftSize)) {
+            continue;
+        }
+        magSqSum += m_magSq[idx];
+    }
+    Real db = CalcDb::dbPower(magSqSum);
+    return db;
+}
+
+// Calculate peak power in a channel containing the specified bin
+Real FreqScannerSink::peakPower(int bin) const
+{
+    // Skip bin between halfway between channels
+    // Then skip first and last bins, to avoid spectral leakage (particularly at DC)
+    int startBin = bin - m_binsPerChannel/2 + 1 + 1;
+    Real maxMagSq = m_magSq[startBin];
+    for (int i = 1; i < m_binsPerChannel - 2 - 1; i++) {
+        int idx = startBin + i;
+        if ((idx < 0) || (idx >= m_fftSize)) {
+            continue;
+        }
+        maxMagSq = std::max(maxMagSq, m_magSq[idx]);
+    }
+    Real db = CalcDb::dbPower(maxMagSq);
+    return db;
+}
+
+Real FreqScannerSink::magSq(int bin) const
+{
+    Complex c = m_fft->out()[bin];
+    Real v = c.real() * c.real() + c.imag() * c.imag();
+    Real magsq = v / (m_fftSize * m_fftSize);
+    return magsq;
+}
+
+void FreqScannerSink::applyChannelSettings(int channelSampleRate, int channelFrequencyOffset, int scannerSampleRate, int fftSize, int binsPerChannel, bool force)
+{
+    qDebug() << "FreqScannerSink::applyChannelSettings:"
+            << " channelSampleRate: " << channelSampleRate
+            << " channelFrequencyOffset: " << channelFrequencyOffset
+            << " scannerSampleRate: " << scannerSampleRate
+            << " fftSize: " << fftSize
+            << " binsPerChannel: " << binsPerChannel;
+
+    if ((m_channelFrequencyOffset != channelFrequencyOffset) ||
+        (m_channelSampleRate != channelSampleRate) || force)
+    {
+        m_nco.setFreq(-channelFrequencyOffset, channelSampleRate);
+    }
+
+    if ((m_channelSampleRate != channelSampleRate) || (m_scannerSampleRate != scannerSampleRate) || force)
+    {
+        m_interpolator.create(16, channelSampleRate, scannerSampleRate / 2.0); // Highest cutoff, so we don't attentuate first/last channel
+        m_interpolatorDistance = (Real) channelSampleRate / (Real)scannerSampleRate;
+        m_interpolatorDistanceRemain = m_interpolatorDistance;
+    }
+
+    if ((m_fftSize != fftSize) || force)
+    {
+        FFTFactory* fftFactory = DSPEngine::instance()->getFFTFactory();
+        if (m_fftSequence >= 0) {
+            fftFactory->releaseEngine(fftSize, false, m_fftSequence);
+        }
+        m_fftSequence = fftFactory->getEngine(fftSize, false, &m_fft);
+        m_fftCounter = 0;
+        m_fftStartTime = QDateTime::currentDateTime();
+        m_fftWindow.create(FFTWindow::Hanning, fftSize);
+
+        int averages = m_settings.m_scanTime * scannerSampleRate / 2 / fftSize;
+        m_fftAverage.resize(fftSize, averages);
+        m_magSq.resize(fftSize);
+    }
+
+    m_channelSampleRate = channelSampleRate;
+    m_channelFrequencyOffset = channelFrequencyOffset;
+    m_scannerSampleRate = scannerSampleRate;
+    m_fftSize = fftSize;
+    m_binsPerChannel = binsPerChannel;
+}
+
+void FreqScannerSink::applySettings(const FreqScannerSettings& settings, const QStringList& settingsKeys, bool force)
+{
+    qDebug() << "FreqScannerSink::applySettings:"
+             << settings.getDebugString(settingsKeys, force)
+             << " force: " << force;
+
+    if (settingsKeys.contains("scanTime") || force)
+    {
+        int averages = settings.m_scanTime * m_scannerSampleRate / 2 / m_fftSize;
+        m_fftAverage.resize(m_fftSize, averages);
+    }
+
+    if (force) {
+        m_settings = settings;
+    } else {
+        m_settings.applySettings(settingsKeys, settings);
+    }
+}
diff --git a/plugins/channelrx/freqscanner/freqscannersink.h b/plugins/channelrx/freqscanner/freqscannersink.h
new file mode 100644
index 000000000..16b276d6e
--- /dev/null
+++ b/plugins/channelrx/freqscanner/freqscannersink.h
@@ -0,0 +1,86 @@
+///////////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2019 Edouard Griffiths, F4EXB                                   //
+// Copyright (C) 2023 Jon Beniston, M7RCE                                        //
+//                                                                               //
+// This program is free software; you can redistribute it and/or modify          //
+// it under the terms of the GNU General Public License as published by          //
+// the Free Software Foundation as version 3 of the License, or                  //
+// (at your option) any later version.                                           //
+//                                                                               //
+// This program is distributed in the hope that it will be useful,               //
+// but WITHOUT ANY WARRANTY; without even the implied warranty of                //
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                  //
+// GNU General Public License V3 for more details.                               //
+//                                                                               //
+// You should have received a copy of the GNU General Public License             //
+// along with this program. If not, see <http://www.gnu.org/licenses/>.          //
+///////////////////////////////////////////////////////////////////////////////////
+
+#ifndef INCLUDE_FREQSCANNERSINK_H
+#define INCLUDE_FREQSCANNERSINK_H
+
+#include <QDateTime>
+
+#include "dsp/channelsamplesink.h"
+#include "dsp/nco.h"
+#include "dsp/interpolator.h"
+#include "dsp/fftfactory.h"
+#include "dsp/fftengine.h"
+#include "dsp/fftwindow.h"
+#include "util/fixedaverage2d.h"
+#include "util/messagequeue.h"
+
+#include "freqscannersettings.h"
+
+class ChannelAPI;
+class FreqScanner;
+
+class FreqScannerSink : public ChannelSampleSink {
+public:
+    FreqScannerSink(FreqScanner *packetDemod);
+    ~FreqScannerSink();
+
+    virtual void feed(const SampleVector::const_iterator& begin, const SampleVector::const_iterator& end);
+
+    void applyChannelSettings(int channelSampleRate, int channelFrequencyOffset, int scannerSampleRate, int fftSize, int binsPerChannel, bool force = false);
+    void applySettings(const FreqScannerSettings& settings, const QStringList& settingsKeys, bool force = false);
+    void setMessageQueueToChannel(MessageQueue *messageQueue) { m_messageQueueToChannel = messageQueue; }
+    void setChannel(ChannelAPI *channel) { m_channel = channel; }
+    void setCenterFrequency(qint64 centerFrequency) { m_centerFrequency = centerFrequency; }
+
+private:
+
+    FreqScanner *m_freqScanner;
+    FreqScannerSettings m_settings;
+    ChannelAPI *m_channel;
+    int m_channelSampleRate;
+    int m_channelFrequencyOffset;
+    int m_scannerSampleRate; // Sample rate scanner runs at
+    qint64 m_centerFrequency;
+
+    NCO m_nco;
+    Interpolator m_interpolator;
+    Real m_interpolatorDistance;
+    Real m_interpolatorDistanceRemain;
+
+    MessageQueue *m_messageQueueToChannel;
+
+    int m_fftSequence;
+    FFTEngine *m_fft;
+    int m_fftCounter;
+    FFTWindow m_fftWindow;
+    int m_fftSize;
+    int m_binsPerChannel;
+    QDateTime m_fftStartTime;
+    FixedAverage2D<Real> m_fftAverage;     // magSq average
+    QVector<Real> m_magSq;
+    int m_averageCount;
+
+    void processOneSample(Complex &ci);
+    MessageQueue *getMessageQueueToChannel() { return m_messageQueueToChannel; }
+    Real totalPower(int bin) const;
+    Real peakPower(int bin) const;
+    Real magSq(int bin) const;
+};
+
+#endif // INCLUDE_FREQSCANNERSINK_H
diff --git a/plugins/channelrx/freqscanner/freqscannerwebapiadapter.cpp b/plugins/channelrx/freqscanner/freqscannerwebapiadapter.cpp
new file mode 100644
index 000000000..37dcddef6
--- /dev/null
+++ b/plugins/channelrx/freqscanner/freqscannerwebapiadapter.cpp
@@ -0,0 +1,52 @@
+///////////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2019 Edouard Griffiths, F4EXB.                                  //
+// Copyright (C) 2023 Jon Beniston, M7RCE                                        //
+//                                                                               //
+// This program is free software; you can redistribute it and/or modify          //
+// it under the terms of the GNU General Public License as published by          //
+// the Free Software Foundation as version 3 of the License, or                  //
+// (at your option) any later version.                                           //
+//                                                                               //
+// This program is distributed in the hope that it will be useful,               //
+// but WITHOUT ANY WARRANTY; without even the implied warranty of                //
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                  //
+// GNU General Public License V3 for more details.                               //
+//                                                                               //
+// You should have received a copy of the GNU General Public License             //
+// along with this program. If not, see <http://www.gnu.org/licenses/>.          //
+///////////////////////////////////////////////////////////////////////////////////
+
+#include "SWGChannelSettings.h"
+#include "freqscanner.h"
+#include "freqscannerwebapiadapter.h"
+
+FreqScannerWebAPIAdapter::FreqScannerWebAPIAdapter()
+{}
+
+FreqScannerWebAPIAdapter::~FreqScannerWebAPIAdapter()
+{}
+
+int FreqScannerWebAPIAdapter::webapiSettingsGet(
+        SWGSDRangel::SWGChannelSettings& response,
+        QString& errorMessage)
+{
+    (void) errorMessage;
+    /*response.ssetFreqScannerSettings(new SWGSDRangel::SWGFreqScannerSettings());
+    response.gsetFreqScannerSettings()->init();
+    FreqScanner::webapiFormatChannelSettings(response, m_settings);*/
+
+    return 200;
+}
+
+int FreqScannerWebAPIAdapter::webapiSettingsPutPatch(
+        bool force,
+        const QStringList& channelSettingsKeys,
+        SWGSDRangel::SWGChannelSettings& response,
+        QString& errorMessage)
+{
+    (void) force;
+    (void) errorMessage;
+    FreqScanner::webapiUpdateChannelSettings(m_settings, channelSettingsKeys, response);
+
+    return 200;
+}
diff --git a/plugins/channelrx/freqscanner/freqscannerwebapiadapter.h b/plugins/channelrx/freqscanner/freqscannerwebapiadapter.h
new file mode 100644
index 000000000..e8afc6c50
--- /dev/null
+++ b/plugins/channelrx/freqscanner/freqscannerwebapiadapter.h
@@ -0,0 +1,50 @@
+///////////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2019 Edouard Griffiths, F4EXB.                                  //
+// Copyright (C) 2023 Jon Beniston, M7RCE                                        //
+//                                                                               //
+// This program is free software; you can redistribute it and/or modify          //
+// it under the terms of the GNU General Public License as published by          //
+// the Free Software Foundation as version 3 of the License, or                  //
+// (at your option) any later version.                                           //
+//                                                                               //
+// This program is distributed in the hope that it will be useful,               //
+// but WITHOUT ANY WARRANTY; without even the implied warranty of                //
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                  //
+// GNU General Public License V3 for more details.                               //
+//                                                                               //
+// You should have received a copy of the GNU General Public License             //
+// along with this program. If not, see <http://www.gnu.org/licenses/>.          //
+///////////////////////////////////////////////////////////////////////////////////
+
+#ifndef INCLUDE_FREQSCANNER_WEBAPIADAPTER_H
+#define INCLUDE_FREQSCANNER_WEBAPIADAPTER_H
+
+#include "channel/channelwebapiadapter.h"
+#include "freqscannersettings.h"
+
+/**
+ * Standalone API adapter only for the settings
+ */
+class FreqScannerWebAPIAdapter : public ChannelWebAPIAdapter {
+public:
+    FreqScannerWebAPIAdapter();
+    virtual ~FreqScannerWebAPIAdapter();
+
+    virtual QByteArray serialize() const { return m_settings.serialize(); }
+    virtual bool deserialize(const QByteArray& data) { return m_settings.deserialize(data); }
+
+    virtual int webapiSettingsGet(
+            SWGSDRangel::SWGChannelSettings& response,
+            QString& errorMessage);
+
+    virtual int webapiSettingsPutPatch(
+            bool force,
+            const QStringList& channelSettingsKeys,
+            SWGSDRangel::SWGChannelSettings& response,
+            QString& errorMessage);
+
+private:
+    FreqScannerSettings m_settings;
+};
+
+#endif // INCLUDE_FREQSCANNER_WEBAPIADAPTER_H
diff --git a/plugins/channelrx/freqscanner/readme.md b/plugins/channelrx/freqscanner/readme.md
new file mode 100644
index 000000000..1b3d1ab5f
--- /dev/null
+++ b/plugins/channelrx/freqscanner/readme.md
@@ -0,0 +1,121 @@
+<h1>Frequency Scanner Plugin</h1>
+
+<h2>Introduction</h2>
+
+This plugin can be used to scan a range of frequencies looking for a transmission and then tune another channel (such as an AM or DSD Demod) to that frequency.
+
+<h2>Interface</h2>
+
+The top and bottom bars of the channel window are described [here](../../../sdrgui/channel/readme.md)
+
+![Frequency Scanner plugin GUI](../../../doc/img/FreqScanner_plugin.png)
+
+<h3>1: Channel</h3>
+
+Specifies the channel (such as an AM, NFM or DSD Demod), by device set and channel index, that should be tuned to the active frequency.
+
+<h3>2: Minimum frequency shift from center frequency of reception for channel</h3>
+
+Use the wheels of keyboard to adjust the minimim frequency shift in Hz from the center frequency of reception for the channel (1). Left click on a digit sets the cursor position at this digit. Right click on a digit sets all digits on the right to zero. This effectively floors value at the digit position. Wheels are moved with the mousewheel while pointing at the wheel or by selecting the wheel with the left mouse click and using the keyboard arrows. Pressing shift simultaneously moves digit by 5 and pressing control moves it by 2.
+
+<h3>3: Active frequency power</h3>
+
+Average power in dB relative to a +/- 1.0 amplitude signal received for the active frequency. This is set to '-' while scanning.
+
+<h3>4: TH - Threshold</h3>
+
+Power threshold in dB that determines whether a frequency is active or not.
+
+<h3>5: t_delta_f - Tune time</h3>
+
+Specifies the time in milliseconds that the Frequency Scanner should wait after adjusting the device center frequency, before starting a measurement.
+This time should take in to account PLL settle time and the device to host transfer latency, so that the measurement only starts when IQ data
+that corresponds to the set frequency is being recieved.
+
+<h3>6: t_s - Scan time</h3>
+
+Specifies the time in seconds that the Frequency Scanner will average its channel power measurement over.
+
+<h3>7: t_rtx - Retransmission Time</h3>
+
+Specifies the time in seconds that the Frequency Scanner will wait after the power on the active frequency falls below the threshold, before restarting
+scanning. This allows for a temporary break in transmission.
+
+<h3>8: Ch BW - Channel Bandwidth</h3>
+
+This specifies the bandwidth of the channels to be scanned.
+
+<h3>9: Pri - Priority</h3>
+
+Specifies which frequency will be chosen as the active frequency, when multiple frequencies exceed the threshold (4):
+
+- Max power: The frequency with the highest power will be chosen
+- Table order: The frequency first in the frequency table (14) will be chosen.
+
+<h3>10: Meas - Power Measurement</h3>
+
+Specifies how power is measured. In both cases, a FFT is used, with the channel bandwidth being spread over 8 to 32 bins, with the first and last bins being excluded from the measurement (to reduce spectral leakage from adjacent channels):
+
+- Peak: Power is the highest value in all of the bins, averaged over the scan time (6).
+- Total: Power is the sum of power in all of the bins, averaged over the scan time (6).
+ 
+Peak can be used when you wish to set the threshold roughly according to the level displayed in the Main Spectrum.
+Total is potentially more useful for wideband signals, that are close to the noise floor.
+
+<h3>11: Run Mode</h3>
+
+Specifies the run mode:
+
+- Single: All frequencies are scanned once. Channel (1) is tuned to the active frequency at the end of the scan. The scan does not repeat.
+- Continuous: All frequencies scanned, with channel (1) being tuned to active frequency at the end of the scan. Scan repeats once the power on the active frequency falls below the threshold (4) for longer than the retransmission time (7).
+- Scan only: All frequencies are scanned repeatedly. The channel will not be tuned. This mode is just for counting how often frequencies are active, which can be seen in the Active Count column in the frequency table (14).
+
+<h3>12: Start/Stop Scanning</h3>
+
+Press this button to start or stop scanning.
+
+<h3>13: Status Text</h3>
+
+Displays the current status of the Frequency Scanner.
+
+- "Scanning": When scanning for active frequencies.
+- Frequency and annotation for active frequency.
+
+<h3>14: Frequency Table</h3>
+
+The frequency table contains the list of frequencies to be scanned, along with results of a scan. The columns are:
+
+- Freq (Hz): Specifies the channel center frequencies to be scanned. These should be spaced by integer multiples of the channel bandwidth (8). Values should be entered in Hertz.
+- Annotation: An annotation (description) for the frequency, that is based on the closest matching [annotation marker](../../../sdrgui/gui/spectrummarkers.md) in the Main Spectrum.
+- Enable: Determines whether the frequency will be scanned. This can be used to temporaily disable frequencies you aren't interested in.
+- Power (dB): Displays the measured power in decibels during the previous scan. The cell will have a green background if the power was above the threshold (4).
+- Active Count: Displays the number of scans in which the power for this frequency was above the threshold (4). This allows you to see which frequencies are commonly in use.
+- Notes: Available for user-entry of notes/information about this frequency.
+
+When an active frequency is found after a scan, the corresponding row in the table will be selected.
+
+Right clicking on a cell will display a popup menu:
+
+- Copy contents of cell to clipboard.
+- Tune selected channel (1) to the frequency in the row clicked on.
+
+<h3>15: Add</h3>
+
+Press to add a single row to the frequency table (14).
+
+<h3>16: Add Range</h3>
+
+Press to add a range of frequencies to the frequency table (14). A dialog is displayed with start and stop frequencies, as well as a step value.
+The step value should typically be an integer multiple of the channel bandwidth (8).
+
+<h3>17: Remove</h3>
+
+Removes the selected rows from the frequency table (14).
+
+<h3>18: Up</h3>
+
+Moves the selected rows up the frequency table (14).
+
+<h3>19: Down</h3>
+
+Moves the selected rows the the frequency table (14).
diff --git a/sdrbase/channel/channelwebapiutils.cpp b/sdrbase/channel/channelwebapiutils.cpp
index 51bb68d95..25527223d 100644
--- a/sdrbase/channel/channelwebapiutils.cpp
+++ b/sdrbase/channel/channelwebapiutils.cpp
@@ -937,6 +937,47 @@ bool ChannelWebAPIUtils::setFrequencyOffset(unsigned int deviceIndex, int channe
     return false;
 }
 
+bool ChannelWebAPIUtils::setAudioMute(unsigned int deviceIndex, int channelIndex, bool mute)
+{
+    SWGSDRangel::SWGChannelSettings channelSettingsResponse;
+    QString errorResponse;
+    int httpRC;
+    QJsonObject* jsonObj;
+
+    ChannelAPI* channel = MainCore::instance()->getChannel(deviceIndex, channelIndex);
+    if (channel != nullptr)
+    {
+        httpRC = channel->webapiSettingsGet(channelSettingsResponse, errorResponse);
+        if (httpRC / 100 != 2)
+        {
+            qWarning("ChannelWebAPIUtils::setAudioMute: get channel settings error %d: %s",
+                httpRC, qPrintable(errorResponse));
+            return false;
+        }
+
+        jsonObj = channelSettingsResponse.asJsonObject();
+
+        if (WebAPIUtils::setSubObjectInt(*jsonObj, "audioMute", (int)mute))
+        {
+            QStringList keys;
+            keys.append("audioMute");
+            channelSettingsResponse.init();
+            channelSettingsResponse.fromJsonObject(*jsonObj);
+            httpRC = channel->webapiSettingsPutPatch(false, keys, channelSettingsResponse, errorResponse);
+            if (httpRC / 100 != 2)
+            {
+                qWarning("ChannelWebAPIUtils::setAudioMute: patch channel settings error %d: %s",
+                    httpRC, qPrintable(errorResponse));
+                return false;
+            }
+
+            return true;
+        }
+    }
+    return false;
+}
+
+
 // Start or stop all file sinks in a given device set
 bool ChannelWebAPIUtils::startStopFileSinks(unsigned int deviceIndex, bool start)
 {
diff --git a/sdrbase/channel/channelwebapiutils.h b/sdrbase/channel/channelwebapiutils.h
index cce4fe7e4..2de9b5eac 100644
--- a/sdrbase/channel/channelwebapiutils.h
+++ b/sdrbase/channel/channelwebapiutils.h
@@ -60,6 +60,7 @@ public:
     static bool stop(unsigned int deviceIndex, int subsystemIndex=0);
     static bool getFrequencyOffset(unsigned int deviceIndex, int channelIndex, int& offset);
     static bool setFrequencyOffset(unsigned int deviceIndex, int channelIndex, int offset);
+    static bool setAudioMute(unsigned int deviceIndex, int channelIndex, bool mute);
     static bool startStopFileSinks(unsigned int deviceIndex, bool start);
     static bool satelliteAOS(const QString name, bool northToSouthPass, const QString &tle, QDateTime dateTime);
     static bool satelliteLOS(const QString name);
diff --git a/sdrbase/webapi/webapirequestmapper.cpp b/sdrbase/webapi/webapirequestmapper.cpp
index 06ae1ebf1..34441fe4e 100644
--- a/sdrbase/webapi/webapirequestmapper.cpp
+++ b/sdrbase/webapi/webapirequestmapper.cpp
@@ -4523,6 +4523,11 @@ bool WebAPIRequestMapper::getChannelSettings(
             channelSettings->setFreeDvModSettings(new SWGSDRangel::SWGFreeDVModSettings());
             channelSettings->getFreeDvModSettings()->fromJsonObject(settingsJsonObject);
         }
+        else if (channelSettingsKey == "FreqScannerSettings")
+        {
+            //channelSettings->setFreqScannerSettings(new SWGSDRangel::SWGFreqScannerSettings());
+            //channelSettings->getFreqScannerSettings()->fromJsonObject(settingsJsonObject);
+        }
         else if (channelSettingsKey == "FreqTrackerSettings")
         {
             channelSettings->setFreqTrackerSettings(new SWGSDRangel::SWGFreqTrackerSettings());
@@ -5442,6 +5447,8 @@ void WebAPIRequestMapper::resetChannelSettings(SWGSDRangel::SWGChannelSettings&
     channelSettings.setDatvModSettings(nullptr);
     channelSettings.setDabDemodSettings(nullptr);
     channelSettings.setDsdDemodSettings(nullptr);
+    //channelSettings.setFreqScannerSettings(nullptr);
+    channelSettings.setFreqTrackerSettings(nullptr);
     channelSettings.setHeatMapSettings(nullptr);
     channelSettings.setIeee802154ModSettings(nullptr);
     channelSettings.setIlsDemodSettings(nullptr);
@@ -5484,6 +5491,8 @@ void WebAPIRequestMapper::resetChannelReport(SWGSDRangel::SWGChannelReport& chan
     channelReport.setBfmDemodReport(nullptr);
     channelReport.setDatvModReport(nullptr);
     channelReport.setDsdDemodReport(nullptr);
+    //channelReport.setFreqScannerReport(nullptr);
+    channelReport.setFreqTrackerReport(nullptr);
     channelReport.setHeatMapReport(nullptr);
     channelReport.setIlsDemodReport(nullptr);
     channelReport.setNavtexDemodReport(nullptr);
diff --git a/sdrbase/webapi/webapiutils.cpp b/sdrbase/webapi/webapiutils.cpp
index 680366844..d8360d73b 100644
--- a/sdrbase/webapi/webapiutils.cpp
+++ b/sdrbase/webapi/webapiutils.cpp
@@ -47,6 +47,7 @@ const QMap<QString, QString> WebAPIUtils::m_channelURIToSettingsKey = {
     {"sdrangel.channeltx.filesource", "FileSourceSettings"},
     {"sdrangel.channel.freedvdemod", "FreeDVDemodSettings"},
     {"sdrangel.channeltx.freedvmod", "FreeDVModSettings"},
+    {"sdrangel.channel.freqscanner", "FreqScannerSettings"},
     {"sdrangel.channel.freqtracker", "FreqTrackerSettings"},
     {"sdrangel.channel.heatmap", "HeatMapSettings"},
     {"sdrangel.channel.ilsdemod", "ILSDemodSettings"},
@@ -168,6 +169,7 @@ const QMap<QString, QString> WebAPIUtils::m_channelTypeToSettingsKey = {
     {"FileSource", "FileSourceSettings"},
     {"FreeDVDemod", "FreeDVDemodSettings"},
     {"FreeDVMod", "FreeDVModSettings"},
+    {"FreqScanner", "FreqScannerSettings"},
     {"FreqTracker", "FreqTrackerSettings"},
     {"HeatMap", "HeatMapSettings"},
     {"IEEE_802_15_4_Mod", "IEEE_802_15_4_ModSettings"},
diff --git a/sdrgui/gui/frequencydelegate.cpp b/sdrgui/gui/frequencydelegate.cpp
index 3b063ad81..cb4a2b470 100644
--- a/sdrgui/gui/frequencydelegate.cpp
+++ b/sdrgui/gui/frequencydelegate.cpp
@@ -15,9 +15,11 @@
 // along with this program. If not, see <http://www.gnu.org/licenses/>.          //
 ///////////////////////////////////////////////////////////////////////////////////
 
+#include <QLineEdit>
+
 #include "frequencydelegate.h"
 
-FrequencyDelegate::FrequencyDelegate(QString units, int precision, bool group) :
+FrequencyDelegate::FrequencyDelegate(const QString& units, int precision, bool group) :
     m_units(units),
     m_precision(precision),
     m_group(group)
@@ -30,29 +32,107 @@ QString FrequencyDelegate::displayText(const QVariant &value, const QLocale &loc
     qlonglong v = value.toLongLong(&ok);
     if (ok)
     {
-        double d;
-        if (m_units == "GHz") {
-            d = v / 1000000000.0;
-        } else if (m_units == "MHz") {
-            d = v / 1000000.0;
-        } else if (m_units == "kHz") {
-            d = v / 1000.0;
-        } else {
-            d = v;
-        }
-
         QLocale l(locale);
         if (m_group) {
             l.setNumberOptions(l.numberOptions() & ~QLocale::OmitGroupSeparator);
-        } else {
+        }
+        else {
             l.setNumberOptions(l.numberOptions() | QLocale::OmitGroupSeparator);
         }
-        QString s = l.toString(d, 'f', m_precision);
 
-        return QString("%1 %2").arg(s).arg(m_units);
+        if (m_units == "Auto")
+        {
+            if (v == 0)
+            {
+                return "0 Hz";
+            }
+            else
+            {
+                QString s = QString::number(v);
+                int scale = 1;
+                while (s.endsWith("000"))
+                {
+                    s.chop(3);
+                    scale *= 1000;
+                }
+                v /= scale;
+                double d = v;
+                if ((abs(v) >= 1000) && (m_precision >= 3))
+                {
+                    scale *= 1000;
+                    d /= 1000.0;
+                }
+                QString units;
+                if (scale == 1) {
+                    units = "Hz";
+                } else if (scale == 1000) {
+                    units = "kHz";
+                } else if (scale == 1000000) {
+                    units = "MHz";
+                } else if (scale == 1000000000) {
+                    units = "GHz";
+                }
+                if (scale == 1) {
+                    s = l.toString(d, 'f', 0);
+                } else {
+                    s = l.toString(d, 'f', m_precision);
+                }
+
+                return QString("%1 %2").arg(s).arg(units);
+            }
+        }
+        else
+        {
+            double d;
+            if (m_units == "GHz") {
+                d = v / 1000000000.0;
+            }
+            else if (m_units == "MHz") {
+                d = v / 1000000.0;
+            }
+            else if (m_units == "kHz") {
+                d = v / 1000.0;
+            }
+            else {
+                d = v;
+            }
+
+
+            QString s = l.toString(d, 'f', m_precision);
+
+            return QString("%1 %2").arg(s).arg(m_units);
+        }
     }
     else
     {
         return value.toString();
     }
 }
+
+QWidget* FrequencyDelegate::createEditor(QWidget* parent, const QStyleOptionViewItem& option, const QModelIndex& index) const
+{
+    QLineEdit* editor = new QLineEdit(parent);
+    QIntValidator* validator = new QIntValidator();
+    validator->setBottom(0);
+    editor->setValidator(validator);
+    return editor;
+}
+
+void FrequencyDelegate::setEditorData(QWidget* editor, const QModelIndex& index) const
+{
+    QString value = index.model()->data(index, Qt::EditRole).toString();
+    QLineEdit* line = static_cast<QLineEdit*>(editor);
+    line->setText(value);
+}
+
+void FrequencyDelegate::setModelData(QWidget* editor, QAbstractItemModel* model, const QModelIndex& index) const
+{
+    QLineEdit* line = static_cast<QLineEdit*>(editor);
+    QString value = line->text();
+    model->setData(index, value);
+}
+
+void FrequencyDelegate::updateEditorGeometry(QWidget* editor, const QStyleOptionViewItem& option, const QModelIndex& index) const
+{
+    editor->setGeometry(option.rect);
+}
diff --git a/sdrgui/gui/frequencydelegate.h b/sdrgui/gui/frequencydelegate.h
index 4899bbee6..8520c5907 100644
--- a/sdrgui/gui/frequencydelegate.h
+++ b/sdrgui/gui/frequencydelegate.h
@@ -26,8 +26,14 @@
 class SDRGUI_API FrequencyDelegate : public QStyledItemDelegate {
 
 public:
-    FrequencyDelegate(QString units = "kHz", int precision=1, bool group=true);
-    virtual QString displayText(const QVariant &value, const QLocale &locale) const override;
+    FrequencyDelegate(const QString& units = "kHz", int precision=1, bool group=true);
+    QString displayText(const QVariant &value, const QLocale &locale) const override;
+
+protected:
+    QWidget* createEditor(QWidget* parent, const QStyleOptionViewItem& option, const QModelIndex& index) const;
+    void setEditorData(QWidget* editor, const QModelIndex& index) const;
+    void setModelData(QWidget* editor, QAbstractItemModel* model, const QModelIndex& index) const;
+    void updateEditorGeometry(QWidget* editor, const QStyleOptionViewItem& option, const QModelIndex& index) const;
 
 private:
     QString m_units;
diff --git a/swagger/sdrangel/api/swagger/include/ChannelReport.yaml b/swagger/sdrangel/api/swagger/include/ChannelReport.yaml
index 01b5d29b8..59aa2633c 100644
--- a/swagger/sdrangel/api/swagger/include/ChannelReport.yaml
+++ b/swagger/sdrangel/api/swagger/include/ChannelReport.yaml
@@ -49,6 +49,8 @@ ChannelReport:
       $ref: "http://swgserver:8081/api/swagger/include/FreeDVDemod.yaml#/FreeDVDemodReport"
     FreeDVModReport:
       $ref: "http://swgserver:8081/api/swagger/include/FreeDVMod.yaml#/FreeDVModReport"
+    FreqScannerReport:
+      $ref: "http://swgserver:8081/api/swagger/include/FreqScanner.yaml#/FreqScannerReport"
     FreqTrackerReport:
       $ref: "http://swgserver:8081/api/swagger/include/FreqTracker.yaml#/FreqTrackerReport"
     FT8DemodReport:
diff --git a/swagger/sdrangel/api/swagger/include/ChannelSettings.yaml b/swagger/sdrangel/api/swagger/include/ChannelSettings.yaml
index 42e566dfb..f19c7ffc5 100644
--- a/swagger/sdrangel/api/swagger/include/ChannelSettings.yaml
+++ b/swagger/sdrangel/api/swagger/include/ChannelSettings.yaml
@@ -63,6 +63,8 @@ ChannelSettings:
       $ref: "http://swgserver:8081/api/swagger/include/FreeDVDemod.yaml#/FreeDVDemodSettings"
     FreeDVModSettings:
       $ref: "http://swgserver:8081/api/swagger/include/FreeDVMod.yaml#/FreeDVModSettings"
+    FreqScannerSettings:
+      $ref: "http://swgserver:8081/api/swagger/include/FreqScanner.yaml#/FreqScannerSettings"
     FreqTrackerSettings:
       $ref: "http://swgserver:8081/api/swagger/include/FreqTracker.yaml#/FreqTrackerSettings"
     FT8DemodSettings:
diff --git a/swagger/sdrangel/api/swagger/include/FreqScanner.yaml b/swagger/sdrangel/api/swagger/include/FreqScanner.yaml
new file mode 100644
index 000000000..82d69a185
--- /dev/null
+++ b/swagger/sdrangel/api/swagger/include/FreqScanner.yaml
@@ -0,0 +1,70 @@
+FreqTrackerSettings:
+  description: FreqTracker
+  properties:
+    channelBandwidth:
+      description: channel RF bandwidth in Hz
+      type: integer
+    channelFrequencyOffset:
+      description: channel center frequency shift from baseband center in Hz
+      type: integer
+    threshold:
+      type: number
+      format: float
+    m_frequencies:
+      type: array
+      items:
+        type: integer
+        format: int64
+    m_enabled:
+      type: array
+      items:
+        type: integer
+    m_notes:
+      type: array
+      items:
+        type: string
+    channel:
+      type: string
+    scanTime:
+      type: number
+      format: float
+    retransmitTime:
+      type: number
+      format: float
+    tuneTime:
+      type: number
+      format: float
+    priority:
+      type: integer
+    measurement:
+      type: integer
+    mode:
+      type: integer
+    rgbColor:
+      type: integer
+    title:
+      type: string
+    streamIndex:
+      description: MIMO channel. Not relevant when connected to SI (single Rx).
+      type: integer
+    useReverseAPI:
+      description: Synchronize with reverse API (1 for yes, 0 for no)
+      type: integer
+    reverseAPIAddress:
+      type: string
+    reverseAPIPort:
+      type: integer
+    reverseAPIDeviceIndex:
+      type: integer
+    reverseAPIChannelIndex:
+      type: integer
+    channelMarker:
+      $ref: "http://swgserver:8081/api/swagger/include/ChannelMarker.yaml#/ChannelMarker"
+    rollupState:
+      $ref: "http://swgserver:8081/api/swagger/include/RollupState.yaml#/RollupState"
+
+FreqScannerReport:
+  description: FreqScanner
+  properties:
+    channelSampleRate:
+      type: integer

From b42b6be910f63fd3075a743cdc3fe90ba5dc05e5 Mon Sep 17 00:00:00 2001
From: srcejon <jon@beniston.com>
Date: Thu, 28 Sep 2023 18:23:15 +0100
Subject: [PATCH 02/23] Add Freq Scanner

---
 plugins/channelrx/CMakeLists.txt | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/plugins/channelrx/CMakeLists.txt b/plugins/channelrx/CMakeLists.txt
index 7721c1960..c2b2ae395 100644
--- a/plugins/channelrx/CMakeLists.txt
+++ b/plugins/channelrx/CMakeLists.txt
@@ -1,5 +1,9 @@
 project(demod)
 
+if (ENABLE_CHANNELRX_FREQSCANNER)
+    add_subdirectory(freqscanner)
+endif()
+
 if (ENABLE_CHANNELRX_DEMODADSB AND Qt${QT_DEFAULT_MAJOR_VERSION}Quick_FOUND AND Qt${QT_DEFAULT_MAJOR_VERSION}QuickWidgets_FOUND AND Qt${QT_DEFAULT_MAJOR_VERSION}Positioning_FOUND AND Qt${QT_DEFAULT_MAJOR_VERSION}TextToSpeech_FOUND)
     add_subdirectory(demodadsb)
     # add_subdirectory(demodvormc)

From 2192a054ed81f8d0a5db1c8475c51015d03df65c Mon Sep 17 00:00:00 2001
From: Jon Beniston <jon@beniston.com>
Date: Thu, 28 Sep 2023 19:02:58 +0100
Subject: [PATCH 03/23] Generate swagger files for Freq Scanner

---
 plugins/channelrx/freqscanner/freqscanner.cpp | 162 ++---
 .../channelrx/freqscanner/freqscannergui.cpp  |   8 +-
 .../freqscanner/freqscannersettings.h         |   1 -
 .../channelrx/freqscanner/freqscannersink.cpp |   5 +-
 .../freqscanner/freqscannerwebapiadapter.cpp  |   6 +-
 sdrbase/webapi/webapirequestmapper.cpp        |   8 +-
 .../api/swagger/include/FreqScanner.yaml      |   4 +-
 .../code/qt5/client/SWGChannelReport.cpp      |  25 +
 .../code/qt5/client/SWGChannelReport.h        |   7 +
 .../code/qt5/client/SWGChannelSettings.cpp    |  25 +
 .../code/qt5/client/SWGChannelSettings.h      |   7 +
 .../code/qt5/client/SWGFreqScannerReport.cpp  | 108 +++
 .../code/qt5/client/SWGFreqScannerReport.h    |  58 ++
 .../qt5/client/SWGFreqScannerSettings.cpp     | 636 ++++++++++++++++++
 .../code/qt5/client/SWGFreqScannerSettings.h  | 194 ++++++
 .../code/qt5/client/SWGModelFactory.h         |  12 +
 16 files changed, 1147 insertions(+), 119 deletions(-)
 create mode 100644 swagger/sdrangel/code/qt5/client/SWGFreqScannerReport.cpp
 create mode 100644 swagger/sdrangel/code/qt5/client/SWGFreqScannerReport.h
 create mode 100644 swagger/sdrangel/code/qt5/client/SWGFreqScannerSettings.cpp
 create mode 100644 swagger/sdrangel/code/qt5/client/SWGFreqScannerSettings.h

diff --git a/plugins/channelrx/freqscanner/freqscanner.cpp b/plugins/channelrx/freqscanner/freqscanner.cpp
index 904a94111..38b36a106 100644
--- a/plugins/channelrx/freqscanner/freqscanner.cpp
+++ b/plugins/channelrx/freqscanner/freqscanner.cpp
@@ -30,7 +30,7 @@
 
 #include "SWGChannelSettings.h"
 #include "SWGWorkspaceInfo.h"
-//#include "SWGFreqScannerSettings.h"
+#include "SWGFreqScannerSettings.h"
 #include "SWGChannelReport.h"
 #include "SWGMapItem.h"
 
@@ -285,9 +285,7 @@ void FreqScanner::initScan()
         qInfo() << "m_minFFTStartTime" << m_minFFTStartTime.toString("ss.z");
     }
 
-    qDebug() << "********* initScan: Clear results";
     m_scanResults.clear();
-    qDebug() << "********* initScan: Clear results done";
 
     if (m_guiMessageQueue) {
         m_guiMessageQueue->push(FreqScanner::MsgReportScanning::create());
@@ -301,6 +299,8 @@ void FreqScanner::processScanResults(const QDateTime& fftStartTime, const QList<
 
     switch (m_state)
     {
+    case IDLE:
+        break;
 
     case START_SCAN:
         {
@@ -642,9 +642,9 @@ int FreqScanner::webapiSettingsGet(
         QString& errorMessage)
 {
     (void) errorMessage;
-    /*response.ssetFreqScannerSettings(new SWGSDRangel::SWGFreqScannerSettings());
-    response.gsetFreqScannerSettings()->init();
-    webapiFormatChannelSettings(response, m_settings);*/
+    response.setFreqScannerSettings(new SWGSDRangel::SWGFreqScannerSettings());
+    response.getFreqScannerSettings()->init();
+    webapiFormatChannelSettings(response, m_settings);
     return 200;
 }
 
@@ -687,9 +687,9 @@ int FreqScanner::webapiReportGet(
             QString& errorMessage)
 {
     (void) errorMessage;
-    /*response.ssetFreqScannerReport(new SWGSDRangel::SWGFreqScannerReport());
-    response.gsetFreqScannerReport()->init();
-    webapiFormatChannelReport(response);*/
+    response.setFreqScannerReport(new SWGSDRangel::SWGFreqScannerReport());
+    response.getFreqScannerReport()->init();
+    webapiFormatChannelReport(response);
     return 200;
 }
 
@@ -698,134 +698,105 @@ void FreqScanner::webapiUpdateChannelSettings(
         const QStringList& channelSettingsKeys,
         SWGSDRangel::SWGChannelSettings& response)
 {
-    /*if (channelSettingsKeys.contains("inputFrequencyOffset")) {
-        settings.m_inputFrequencyOffset = response.gsetFreqScannerSettings()->getInputFrequencyOffset();
+    if (channelSettingsKeys.contains("channelFrequencyOffset")) {
+        settings.m_channelFrequencyOffset = response.getFreqScannerSettings()->getChannelFrequencyOffset();
     }
-    if (channelSettingsKeys.contains("rfBandwidth")) {
-        settings.m_channelBandwidth = response.gsetFreqScannerSettings()->getRfBandwidth();
-    }
-    if (channelSettingsKeys.contains("audioMute")) {
-        settings.m_audioMute = response.gsetFreqScannerSettings()->getAudioMute();
+    if (channelSettingsKeys.contains("channelBandwidth")) {
+        settings.m_channelBandwidth = response.getFreqScannerSettings()->getChannelBandwidth();
     }
     if (channelSettingsKeys.contains("threshold")) {
-        settings.m_threshold = response.gsetFreqScannerSettings()->getThreshold();
-    }
-    if (channelSettingsKeys.contains("logFilename")) {
-        settings.m_logFilename = *response.getAdsbDemodSettings()->getLogFilename();
-    }
-    if (channelSettingsKeys.contains("logEnabled")) {
-        settings.m_logEnabled = response.getAdsbDemodSettings()->getLogEnabled();
+        settings.m_threshold = response.getFreqScannerSettings()->getThreshold();
     }
     if (channelSettingsKeys.contains("rgbColor")) {
-        settings.m_rgbColor = response.gsetFreqScannerSettings()->getRgbColor();
+        settings.m_rgbColor = response.getFreqScannerSettings()->getRgbColor();
     }
     if (channelSettingsKeys.contains("title")) {
-        settings.m_title = *response.gsetFreqScannerSettings()->getTitle();
+        settings.m_title = *response.getFreqScannerSettings()->getTitle();
     }
     if (channelSettingsKeys.contains("streamIndex")) {
-        settings.m_streamIndex = response.gsetFreqScannerSettings()->getStreamIndex();
+        settings.m_streamIndex = response.getFreqScannerSettings()->getStreamIndex();
     }
     if (channelSettingsKeys.contains("useReverseAPI")) {
-        settings.m_useReverseAPI = response.gsetFreqScannerSettings()->getUseReverseApi() != 0;
+        settings.m_useReverseAPI = response.getFreqScannerSettings()->getUseReverseApi() != 0;
     }
     if (channelSettingsKeys.contains("reverseAPIAddress")) {
-        settings.m_reverseAPIAddress = *response.gsetFreqScannerSettings()->getReverseApiAddress();
+        settings.m_reverseAPIAddress = *response.getFreqScannerSettings()->getReverseApiAddress();
     }
     if (channelSettingsKeys.contains("reverseAPIPort")) {
-        settings.m_reverseAPIPort = response.gsetFreqScannerSettings()->getReverseApiPort();
+        settings.m_reverseAPIPort = response.getFreqScannerSettings()->getReverseApiPort();
     }
     if (channelSettingsKeys.contains("reverseAPIDeviceIndex")) {
-        settings.m_reverseAPIDeviceIndex = response.gsetFreqScannerSettings()->getReverseApiDeviceIndex();
+        settings.m_reverseAPIDeviceIndex = response.getFreqScannerSettings()->getReverseApiDeviceIndex();
     }
     if (channelSettingsKeys.contains("reverseAPIChannelIndex")) {
-        settings.m_reverseAPIChannelIndex = response.gsetFreqScannerSettings()->getReverseApiChannelIndex();
-    }
-    if (settings.m_scopeGUI && channelSettingsKeys.contains("scopeConfig")) {
-        settings.m_scopeGUI->updateFrom(channelSettingsKeys, response.gsetFreqScannerSettings()->getScopeConfig());
+        settings.m_reverseAPIChannelIndex = response.getFreqScannerSettings()->getReverseApiChannelIndex();
     }
     if (settings.m_channelMarker && channelSettingsKeys.contains("channelMarker")) {
-        settings.m_channelMarker->updateFrom(channelSettingsKeys, response.gsetFreqScannerSettings()->getChannelMarker());
+        settings.m_channelMarker->updateFrom(channelSettingsKeys, response.getFreqScannerSettings()->getChannelMarker());
     }
     if (settings.m_rollupState && channelSettingsKeys.contains("rollupState")) {
-        settings.m_rollupState->updateFrom(channelSettingsKeys, response.gsetFreqScannerSettings()->getRollupState());
-    }*/
+        settings.m_rollupState->updateFrom(channelSettingsKeys, response.getFreqScannerSettings()->getRollupState());
+    }
 }
 
 void FreqScanner::webapiFormatChannelSettings(SWGSDRangel::SWGChannelSettings& response, const FreqScannerSettings& settings)
 {
-    /*response.gsetFreqScannerSettings()->setInputFrequencyOffset(settings.m_inputFrequencyOffset);
-    response.gsetFreqScannerSettings()->setRfBandwidth(settings.m_channelBandwidth);
-    response.gsetFreqScannerSettings()->setAudioMute(settings.m_audioMute);
-    response.gsetFreqScannerSettings()->setThreshold(settings.m_threshold);
-    response.gsetFreqScannerSettings()->setLogFilename(new QString(settings.m_logFilename));
-    response.gsetFreqScannerSettings()->setLogEnabled(settings.m_logEnabled);
+    response.getFreqScannerSettings()->setChannelFrequencyOffset(settings.m_channelFrequencyOffset);
+    response.getFreqScannerSettings()->setChannelBandwidth(settings.m_channelBandwidth);
+    response.getFreqScannerSettings()->setThreshold(settings.m_threshold);
 
-    response.gsetFreqScannerSettings()->setRgbColor(settings.m_rgbColor);
-    if (response.gsetFreqScannerSettings()->getTitle()) {
-        *response.gsetFreqScannerSettings()->getTitle() = settings.m_title;
+    response.getFreqScannerSettings()->setRgbColor(settings.m_rgbColor);
+    if (response.getFreqScannerSettings()->getTitle()) {
+        *response.getFreqScannerSettings()->getTitle() = settings.m_title;
     } else {
-        response.gsetFreqScannerSettings()->setTitle(new QString(settings.m_title));
+        response.getFreqScannerSettings()->setTitle(new QString(settings.m_title));
     }
 
-    response.gsetFreqScannerSettings()->setStreamIndex(settings.m_streamIndex);
-    response.gsetFreqScannerSettings()->setUseReverseApi(settings.m_useReverseAPI ? 1 : 0);
+    response.getFreqScannerSettings()->setStreamIndex(settings.m_streamIndex);
+    response.getFreqScannerSettings()->setUseReverseApi(settings.m_useReverseAPI ? 1 : 0);
 
-    if (response.gsetFreqScannerSettings()->getReverseApiAddress()) {
-        *response.gsetFreqScannerSettings()->getReverseApiAddress() = settings.m_reverseAPIAddress;
+    if (response.getFreqScannerSettings()->getReverseApiAddress()) {
+        *response.getFreqScannerSettings()->getReverseApiAddress() = settings.m_reverseAPIAddress;
     } else {
-        response.gsetFreqScannerSettings()->setReverseApiAddress(new QString(settings.m_reverseAPIAddress));
+        response.getFreqScannerSettings()->setReverseApiAddress(new QString(settings.m_reverseAPIAddress));
     }
 
-    response.gsetFreqScannerSettings()->setReverseApiPort(settings.m_reverseAPIPort);
-    response.gsetFreqScannerSettings()->setReverseApiDeviceIndex(settings.m_reverseAPIDeviceIndex);
-    response.gsetFreqScannerSettings()->setReverseApiChannelIndex(settings.m_reverseAPIChannelIndex);
+    response.getFreqScannerSettings()->setReverseApiPort(settings.m_reverseAPIPort);
+    response.getFreqScannerSettings()->setReverseApiDeviceIndex(settings.m_reverseAPIDeviceIndex);
+    response.getFreqScannerSettings()->setReverseApiChannelIndex(settings.m_reverseAPIChannelIndex);
 
-    if (settings.m_scopeGUI)
-    {
-        if (response.gsetFreqScannerSettings()->getScopeConfig())
-        {
-            settings.m_scopeGUI->formatTo(response.gsetFreqScannerSettings()->getScopeConfig());
-        }
-        else
-        {
-            SWGSDRangel::SWGGLScope *swgGLScope = new SWGSDRangel::SWGGLScope();
-            settings.m_scopeGUI->formatTo(swgGLScope);
-            response.gsetFreqScannerSettings()->setScopeConfig(swgGLScope);
-        }
-    }
     if (settings.m_channelMarker)
     {
-        if (response.gsetFreqScannerSettings()->getChannelMarker())
+        if (response.getFreqScannerSettings()->getChannelMarker())
         {
-            settings.m_channelMarker->formatTo(response.gsetFreqScannerSettings()->getChannelMarker());
+            settings.m_channelMarker->formatTo(response.getFreqScannerSettings()->getChannelMarker());
         }
         else
         {
             SWGSDRangel::SWGChannelMarker *swgChannelMarker = new SWGSDRangel::SWGChannelMarker();
             settings.m_channelMarker->formatTo(swgChannelMarker);
-            response.gsetFreqScannerSettings()->setChannelMarker(swgChannelMarker);
+            response.getFreqScannerSettings()->setChannelMarker(swgChannelMarker);
         }
     }
 
     if (settings.m_rollupState)
     {
-        if (response.gsetFreqScannerSettings()->getRollupState())
+        if (response.getFreqScannerSettings()->getRollupState())
         {
-            settings.m_rollupState->formatTo(response.gsetFreqScannerSettings()->getRollupState());
+            settings.m_rollupState->formatTo(response.getFreqScannerSettings()->getRollupState());
         }
         else
         {
             SWGSDRangel::SWGRollupState *swgRollupState = new SWGSDRangel::SWGRollupState();
             settings.m_rollupState->formatTo(swgRollupState);
-            response.gsetFreqScannerSettings()->setRollupState(swgRollupState);
+            response.getFreqScannerSettings()->setRollupState(swgRollupState);
         }
-    }*/
+    }
 }
 
 void FreqScanner::webapiFormatChannelReport(SWGSDRangel::SWGChannelReport& response)
 {
-    /*response.gsetFreqScannerReport()->setChannelPowerDb(CalcDb::dbPower(magsqAvg));
-    response.gsetFreqScannerReport()->setChannelSampleRate(m_basebandSink->getChannelSampleRate());*/
+    response.getFreqScannerReport()->setChannelSampleRate(m_basebandSink->getChannelSampleRate());
 }
 
 void FreqScanner::webapiReverseSendSettings(const QStringList& channelSettingsKeys, const FreqScannerSettings& settings, bool force)
@@ -860,33 +831,24 @@ void FreqScanner::webapiFormatChannelSettings(
         bool force
 )
 {
-    /*swgChannelSettings->setDirection(0); // Single sink (Rx)
+    swgChannelSettings->setDirection(0); // Single sink (Rx)
     swgChannelSettings->setOriginatorChannelIndex(getIndexInDeviceSet());
     swgChannelSettings->setOriginatorDeviceSetIndex(getDeviceSetIndex());
     swgChannelSettings->setChannelType(new QString("FreqScanner"));
-    swgChannelSettings->ssetFreqScannerSettings(new SWGSDRangel::SWGFreqScannerSettings());
-    SWGSDRangel::SWGFreqScannerSettings *swgFreqScannerSettings = swgChannelSettings->gsetFreqScannerSettings();
+    swgChannelSettings->setFreqScannerSettings(new SWGSDRangel::SWGFreqScannerSettings());
+    SWGSDRangel::SWGFreqScannerSettings *swgFreqScannerSettings = swgChannelSettings->getFreqScannerSettings();
 
     // transfer data that has been modified. When force is on transfer all data except reverse API data
 
-    if (channelSettingsKeys.contains("inputFrequencyOffset") || force) {
-        swgFreqScannerSettings->setInputFrequencyOffset(settings.m_inputFrequencyOffset);
+    if (channelSettingsKeys.contains("channelFrequencyOffset") || force) {
+        swgFreqScannerSettings->setChannelFrequencyOffset(settings.m_channelFrequencyOffset);
     }
-    if (channelSettingsKeys.contains("rfBandwidth") || force) {
-        swgFreqScannerSettings->setRfBandwidth(settings.m_channelBandwidth);
-    }
-    if (channelSettingsKeys.contains("audioMute") || force) {
-        swgFreqScannerSettings->setAudioMute(settings.m_audioMute);
+    if (channelSettingsKeys.contains("channelBandwidth") || force) {
+        swgFreqScannerSettings->setChannelBandwidth(settings.m_channelBandwidth);
     }
     if (channelSettingsKeys.contains("threshold") || force) {
         swgFreqScannerSettings->setThreshold(settings.m_threshold);
     }
-    if (channelSettingsKeys.contains("logFilename") || force) {
-        swgFreqScannerSettings->setLogFilename(new QString(settings.m_logFilename));
-    }
-    if (channelSettingsKeys.contains("logEnabled") || force) {
-        swgFreqScannerSettings->setLogEnabled(settings.m_logEnabled);
-    }
     if (channelSettingsKeys.contains("rgbColor") || force) {
         swgFreqScannerSettings->setRgbColor(settings.m_rgbColor);
     }
@@ -897,13 +859,6 @@ void FreqScanner::webapiFormatChannelSettings(
         swgFreqScannerSettings->setStreamIndex(settings.m_streamIndex);
     }
 
-    if (settings.m_scopeGUI && (channelSettingsKeys.contains("scopeConfig") || force))
-    {
-        SWGSDRangel::SWGGLScope *swgGLScope = new SWGSDRangel::SWGGLScope();
-        settings.m_scopeGUI->formatTo(swgGLScope);
-        swgFreqScannerSettings->setScopeConfig(swgGLScope);
-    }
-
     if (settings.m_channelMarker && (channelSettingsKeys.contains("channelMarker") || force))
     {
         SWGSDRangel::SWGChannelMarker *swgChannelMarker = new SWGSDRangel::SWGChannelMarker();
@@ -916,7 +871,7 @@ void FreqScanner::webapiFormatChannelSettings(
         SWGSDRangel::SWGRollupState *swgRollupState = new SWGSDRangel::SWGRollupState();
         settings.m_rollupState->formatTo(swgRollupState);
         swgFreqScannerSettings->setRollupState(swgRollupState);
-    }*/
+    }
 }
 
 void FreqScanner::networkManagerFinished(QNetworkReply *reply)
@@ -956,7 +911,6 @@ void FreqScanner::handleIndexInDeviceSetChanged(int index)
 void FreqScanner::scanAvailableChannels()
 {
     MainCore* mainCore = MainCore::instance();
-    MessagePipes& messagePipes = mainCore->getMessagePipes();
     std::vector<DeviceSet*>& deviceSets = mainCore->getDeviceSets();
     m_availableChannels.clear();
 
@@ -971,7 +925,7 @@ void FreqScanner::scanAvailableChannels()
                 ChannelAPI* channel = deviceSet->getChannelAt(chi);
 
                 FreqScannerSettings::AvailableChannel availableChannel =
-                    FreqScannerSettings::AvailableChannel{ channel->getDeviceSetIndex(), channel->getIndexInDeviceSet(), channel };
+                    FreqScannerSettings::AvailableChannel{ channel->getDeviceSetIndex(), channel->getIndexInDeviceSet()};
                 m_availableChannels[channel] = availableChannel;
             }
         }
@@ -991,7 +945,7 @@ void FreqScanner::handleChannelAdded(int deviceSetIndex, ChannelAPI* channel)
     if (deviceSourceEngine)
     {
         FreqScannerSettings::AvailableChannel availableChannel =
-            FreqScannerSettings::AvailableChannel{ deviceSetIndex, channel->getIndexInDeviceSet(), channel };
+            FreqScannerSettings::AvailableChannel{ deviceSetIndex, channel->getIndexInDeviceSet()};
         m_availableChannels[channel] = availableChannel;
     }
 
diff --git a/plugins/channelrx/freqscanner/freqscannergui.cpp b/plugins/channelrx/freqscanner/freqscannergui.cpp
index 50f46a0b8..555bec411 100644
--- a/plugins/channelrx/freqscanner/freqscannergui.cpp
+++ b/plugins/channelrx/freqscanner/freqscannergui.cpp
@@ -185,12 +185,12 @@ bool FreqScannerGUI::handleMessage(const Message& message)
             QList<QTableWidgetItem *> items = ui->table->findItems(QString::number(freq), Qt::MatchExactly);
             for (auto item : items) {
                 int row = item->row();
-                QTableWidgetItem* item = ui->table->item(row, COL_POWER);
-                item->setData(Qt::DisplayRole, results[i].m_power);
+                QTableWidgetItem* powerItem = ui->table->item(row, COL_POWER);
+                powerItem->setData(Qt::DisplayRole, results[i].m_power);
                 bool active = results[i].m_power >= m_settings.m_threshold;
                 if (active)
                 {
-                    item->setBackground(Qt::darkGreen);
+                    powerItem->setBackground(Qt::darkGreen);
                     QTableWidgetItem* activeCountItem = ui->table->item(row, COL_ACTIVE_COUNT);
                     activeCountItem->setData(Qt::DisplayRole, activeCountItem->data(Qt::DisplayRole).toInt() + 1);
                 }
@@ -736,7 +736,7 @@ void FreqScannerGUI::updateAnnotation(int row)
         {
             if ((marker.m_startFrequency <= frequency) && (frequency < marker.m_startFrequency + marker.m_bandwidth))
             {
-                if (marker.m_bandwidth == m_settings.m_channelBandwidth) {
+                if (marker.m_bandwidth == (unsigned)m_settings.m_channelBandwidth) {
                     // Exact match
                     annotationItem->setText(marker.m_text);
                     return;
diff --git a/plugins/channelrx/freqscanner/freqscannersettings.h b/plugins/channelrx/freqscanner/freqscannersettings.h
index f6dbd86e6..646c28c01 100644
--- a/plugins/channelrx/freqscanner/freqscannersettings.h
+++ b/plugins/channelrx/freqscanner/freqscannersettings.h
@@ -33,7 +33,6 @@ struct FreqScannerSettings
     {
         int m_deviceSetIndex;
         int m_channelIndex;
-        ChannelAPI* m_channelAPI;
 
         AvailableChannel() = default;
         AvailableChannel(const AvailableChannel&) = default;
diff --git a/plugins/channelrx/freqscanner/freqscannersink.cpp b/plugins/channelrx/freqscanner/freqscannersink.cpp
index bc3625bed..01d8ed203 100644
--- a/plugins/channelrx/freqscanner/freqscannersink.cpp
+++ b/plugins/channelrx/freqscanner/freqscannersink.cpp
@@ -36,7 +36,10 @@ FreqScannerSink::FreqScannerSink(FreqScanner *ilsDemod) :
         m_messageQueueToChannel(nullptr),
         m_fftSequence(-1),
         m_fft(nullptr),
-        m_fftCounter(0)
+        m_fftCounter(0),
+        m_fftSize(1024),
+        m_binsPerChannel(16),
+        m_averageCount(0)
 {
     applySettings(m_settings, QStringList(), true);
     applyChannelSettings(m_channelSampleRate, m_channelFrequencyOffset, 16, 4, true);
diff --git a/plugins/channelrx/freqscanner/freqscannerwebapiadapter.cpp b/plugins/channelrx/freqscanner/freqscannerwebapiadapter.cpp
index 37dcddef6..7d2302f26 100644
--- a/plugins/channelrx/freqscanner/freqscannerwebapiadapter.cpp
+++ b/plugins/channelrx/freqscanner/freqscannerwebapiadapter.cpp
@@ -31,9 +31,9 @@ int FreqScannerWebAPIAdapter::webapiSettingsGet(
         QString& errorMessage)
 {
     (void) errorMessage;
-    /*response.ssetFreqScannerSettings(new SWGSDRangel::SWGFreqScannerSettings());
-    response.gsetFreqScannerSettings()->init();
-    FreqScanner::webapiFormatChannelSettings(response, m_settings);*/
+    response.setFreqScannerSettings(new SWGSDRangel::SWGFreqScannerSettings());
+    response.getFreqScannerSettings()->init();
+    FreqScanner::webapiFormatChannelSettings(response, m_settings);
 
     return 200;
 }
diff --git a/sdrbase/webapi/webapirequestmapper.cpp b/sdrbase/webapi/webapirequestmapper.cpp
index 34441fe4e..b14322f89 100644
--- a/sdrbase/webapi/webapirequestmapper.cpp
+++ b/sdrbase/webapi/webapirequestmapper.cpp
@@ -4525,8 +4525,8 @@ bool WebAPIRequestMapper::getChannelSettings(
         }
         else if (channelSettingsKey == "FreqScannerSettings")
         {
-            //channelSettings->setFreqScannerSettings(new SWGSDRangel::SWGFreqScannerSettings());
-            //channelSettings->getFreqScannerSettings()->fromJsonObject(settingsJsonObject);
+            channelSettings->setFreqScannerSettings(new SWGSDRangel::SWGFreqScannerSettings());
+            channelSettings->getFreqScannerSettings()->fromJsonObject(settingsJsonObject);
         }
         else if (channelSettingsKey == "FreqTrackerSettings")
         {
@@ -5447,7 +5447,7 @@ void WebAPIRequestMapper::resetChannelSettings(SWGSDRangel::SWGChannelSettings&
     channelSettings.setDatvModSettings(nullptr);
     channelSettings.setDabDemodSettings(nullptr);
     channelSettings.setDsdDemodSettings(nullptr);
-    //channelSettings.setFreqScannerSettings(nullptr);
+    channelSettings.setFreqScannerSettings(nullptr);
     channelSettings.setFreqTrackerSettings(nullptr);
     channelSettings.setHeatMapSettings(nullptr);
     channelSettings.setIeee802154ModSettings(nullptr);
@@ -5491,7 +5491,7 @@ void WebAPIRequestMapper::resetChannelReport(SWGSDRangel::SWGChannelReport& chan
     channelReport.setBfmDemodReport(nullptr);
     channelReport.setDatvModReport(nullptr);
     channelReport.setDsdDemodReport(nullptr);
-    //channelReport.setFreqScannerReport(nullptr);
+    channelReport.setFreqScannerReport(nullptr);
     channelReport.setFreqTrackerReport(nullptr);
     channelReport.setHeatMapReport(nullptr);
     channelReport.setIlsDemodReport(nullptr);
diff --git a/swagger/sdrangel/api/swagger/include/FreqScanner.yaml b/swagger/sdrangel/api/swagger/include/FreqScanner.yaml
index 82d69a185..34b669e46 100644
--- a/swagger/sdrangel/api/swagger/include/FreqScanner.yaml
+++ b/swagger/sdrangel/api/swagger/include/FreqScanner.yaml
@@ -1,5 +1,5 @@
-FreqTrackerSettings:
-  description: FreqTracker
+FreqScannerSettings:
+  description: FreqScanner
   properties:
     channelBandwidth:
       description: channel RF bandwidth in Hz
diff --git a/swagger/sdrangel/code/qt5/client/SWGChannelReport.cpp b/swagger/sdrangel/code/qt5/client/SWGChannelReport.cpp
index 15761e378..9f7623373 100644
--- a/swagger/sdrangel/code/qt5/client/SWGChannelReport.cpp
+++ b/swagger/sdrangel/code/qt5/client/SWGChannelReport.cpp
@@ -70,6 +70,8 @@ SWGChannelReport::SWGChannelReport() {
     m_free_dv_demod_report_isSet = false;
     free_dv_mod_report = nullptr;
     m_free_dv_mod_report_isSet = false;
+    freq_scanner_report = nullptr;
+    m_freq_scanner_report_isSet = false;
     freq_tracker_report = nullptr;
     m_freq_tracker_report_isSet = false;
     ft8_demod_report = nullptr;
@@ -176,6 +178,8 @@ SWGChannelReport::init() {
     m_free_dv_demod_report_isSet = false;
     free_dv_mod_report = new SWGFreeDVModReport();
     m_free_dv_mod_report_isSet = false;
+    freq_scanner_report = new SWGFreqScannerReport();
+    m_freq_scanner_report_isSet = false;
     freq_tracker_report = new SWGFreqTrackerReport();
     m_freq_tracker_report_isSet = false;
     ft8_demod_report = new SWGFT8DemodReport();
@@ -297,6 +301,9 @@ SWGChannelReport::cleanup() {
     if(free_dv_mod_report != nullptr) { 
         delete free_dv_mod_report;
     }
+    if(freq_scanner_report != nullptr) { 
+        delete freq_scanner_report;
+    }
     if(freq_tracker_report != nullptr) { 
         delete freq_tracker_report;
     }
@@ -436,6 +443,8 @@ SWGChannelReport::fromJsonObject(QJsonObject &pJson) {
     
     ::SWGSDRangel::setValue(&free_dv_mod_report, pJson["FreeDVModReport"], "SWGFreeDVModReport", "SWGFreeDVModReport");
     
+    ::SWGSDRangel::setValue(&freq_scanner_report, pJson["FreqScannerReport"], "SWGFreqScannerReport", "SWGFreqScannerReport");
+    
     ::SWGSDRangel::setValue(&freq_tracker_report, pJson["FreqTrackerReport"], "SWGFreqTrackerReport", "SWGFreqTrackerReport");
     
     ::SWGSDRangel::setValue(&ft8_demod_report, pJson["FT8DemodReport"], "SWGFT8DemodReport", "SWGFT8DemodReport");
@@ -571,6 +580,9 @@ SWGChannelReport::asJsonObject() {
     if((free_dv_mod_report != nullptr) && (free_dv_mod_report->isSet())){
         toJsonValue(QString("FreeDVModReport"), free_dv_mod_report, obj, QString("SWGFreeDVModReport"));
     }
+    if((freq_scanner_report != nullptr) && (freq_scanner_report->isSet())){
+        toJsonValue(QString("FreqScannerReport"), freq_scanner_report, obj, QString("SWGFreqScannerReport"));
+    }
     if((freq_tracker_report != nullptr) && (freq_tracker_report->isSet())){
         toJsonValue(QString("FreqTrackerReport"), freq_tracker_report, obj, QString("SWGFreqTrackerReport"));
     }
@@ -869,6 +881,16 @@ SWGChannelReport::setFreeDvModReport(SWGFreeDVModReport* free_dv_mod_report) {
     this->m_free_dv_mod_report_isSet = true;
 }
 
+SWGFreqScannerReport*
+SWGChannelReport::getFreqScannerReport() {
+    return freq_scanner_report;
+}
+void
+SWGChannelReport::setFreqScannerReport(SWGFreqScannerReport* freq_scanner_report) {
+    this->freq_scanner_report = freq_scanner_report;
+    this->m_freq_scanner_report_isSet = true;
+}
+
 SWGFreqTrackerReport*
 SWGChannelReport::getFreqTrackerReport() {
     return freq_tracker_report;
@@ -1217,6 +1239,9 @@ SWGChannelReport::isSet(){
         if(free_dv_mod_report && free_dv_mod_report->isSet()){
             isObjectUpdated = true; break;
         }
+        if(freq_scanner_report && freq_scanner_report->isSet()){
+            isObjectUpdated = true; break;
+        }
         if(freq_tracker_report && freq_tracker_report->isSet()){
             isObjectUpdated = true; break;
         }
diff --git a/swagger/sdrangel/code/qt5/client/SWGChannelReport.h b/swagger/sdrangel/code/qt5/client/SWGChannelReport.h
index 7e16b278f..213b76f87 100644
--- a/swagger/sdrangel/code/qt5/client/SWGChannelReport.h
+++ b/swagger/sdrangel/code/qt5/client/SWGChannelReport.h
@@ -41,6 +41,7 @@
 #include "SWGFileSourceReport.h"
 #include "SWGFreeDVDemodReport.h"
 #include "SWGFreeDVModReport.h"
+#include "SWGFreqScannerReport.h"
 #include "SWGFreqTrackerReport.h"
 #include "SWGHeatMapReport.h"
 #include "SWGIEEE_802_15_4_ModReport.h"
@@ -152,6 +153,9 @@ public:
     SWGFreeDVModReport* getFreeDvModReport();
     void setFreeDvModReport(SWGFreeDVModReport* free_dv_mod_report);
 
+    SWGFreqScannerReport* getFreqScannerReport();
+    void setFreqScannerReport(SWGFreqScannerReport* freq_scanner_report);
+
     SWGFreqTrackerReport* getFreqTrackerReport();
     void setFreqTrackerReport(SWGFreqTrackerReport* freq_tracker_report);
 
@@ -303,6 +307,9 @@ private:
     SWGFreeDVModReport* free_dv_mod_report;
     bool m_free_dv_mod_report_isSet;
 
+    SWGFreqScannerReport* freq_scanner_report;
+    bool m_freq_scanner_report_isSet;
+
     SWGFreqTrackerReport* freq_tracker_report;
     bool m_freq_tracker_report_isSet;
 
diff --git a/swagger/sdrangel/code/qt5/client/SWGChannelSettings.cpp b/swagger/sdrangel/code/qt5/client/SWGChannelSettings.cpp
index d65f5fc3f..845e9fa3e 100644
--- a/swagger/sdrangel/code/qt5/client/SWGChannelSettings.cpp
+++ b/swagger/sdrangel/code/qt5/client/SWGChannelSettings.cpp
@@ -82,6 +82,8 @@ SWGChannelSettings::SWGChannelSettings() {
     m_free_dv_demod_settings_isSet = false;
     free_dv_mod_settings = nullptr;
     m_free_dv_mod_settings_isSet = false;
+    freq_scanner_settings = nullptr;
+    m_freq_scanner_settings_isSet = false;
     freq_tracker_settings = nullptr;
     m_freq_tracker_settings_isSet = false;
     ft8_demod_settings = nullptr;
@@ -212,6 +214,8 @@ SWGChannelSettings::init() {
     m_free_dv_demod_settings_isSet = false;
     free_dv_mod_settings = new SWGFreeDVModSettings();
     m_free_dv_mod_settings_isSet = false;
+    freq_scanner_settings = new SWGFreqScannerSettings();
+    m_freq_scanner_settings_isSet = false;
     freq_tracker_settings = new SWGFreqTrackerSettings();
     m_freq_tracker_settings_isSet = false;
     ft8_demod_settings = new SWGFT8DemodSettings();
@@ -359,6 +363,9 @@ SWGChannelSettings::cleanup() {
     if(free_dv_mod_settings != nullptr) { 
         delete free_dv_mod_settings;
     }
+    if(freq_scanner_settings != nullptr) { 
+        delete freq_scanner_settings;
+    }
     if(freq_tracker_settings != nullptr) { 
         delete freq_tracker_settings;
     }
@@ -528,6 +535,8 @@ SWGChannelSettings::fromJsonObject(QJsonObject &pJson) {
     
     ::SWGSDRangel::setValue(&free_dv_mod_settings, pJson["FreeDVModSettings"], "SWGFreeDVModSettings", "SWGFreeDVModSettings");
     
+    ::SWGSDRangel::setValue(&freq_scanner_settings, pJson["FreqScannerSettings"], "SWGFreqScannerSettings", "SWGFreqScannerSettings");
+    
     ::SWGSDRangel::setValue(&freq_tracker_settings, pJson["FreqTrackerSettings"], "SWGFreqTrackerSettings", "SWGFreqTrackerSettings");
     
     ::SWGSDRangel::setValue(&ft8_demod_settings, pJson["FT8DemodSettings"], "SWGFT8DemodSettings", "SWGFT8DemodSettings");
@@ -693,6 +702,9 @@ SWGChannelSettings::asJsonObject() {
     if((free_dv_mod_settings != nullptr) && (free_dv_mod_settings->isSet())){
         toJsonValue(QString("FreeDVModSettings"), free_dv_mod_settings, obj, QString("SWGFreeDVModSettings"));
     }
+    if((freq_scanner_settings != nullptr) && (freq_scanner_settings->isSet())){
+        toJsonValue(QString("FreqScannerSettings"), freq_scanner_settings, obj, QString("SWGFreqScannerSettings"));
+    }
     if((freq_tracker_settings != nullptr) && (freq_tracker_settings->isSet())){
         toJsonValue(QString("FreqTrackerSettings"), freq_tracker_settings, obj, QString("SWGFreqTrackerSettings"));
     }
@@ -1069,6 +1081,16 @@ SWGChannelSettings::setFreeDvModSettings(SWGFreeDVModSettings* free_dv_mod_setti
     this->m_free_dv_mod_settings_isSet = true;
 }
 
+SWGFreqScannerSettings*
+SWGChannelSettings::getFreqScannerSettings() {
+    return freq_scanner_settings;
+}
+void
+SWGChannelSettings::setFreqScannerSettings(SWGFreqScannerSettings* freq_scanner_settings) {
+    this->freq_scanner_settings = freq_scanner_settings;
+    this->m_freq_scanner_settings_isSet = true;
+}
+
 SWGFreqTrackerSettings*
 SWGChannelSettings::getFreqTrackerSettings() {
     return freq_tracker_settings;
@@ -1495,6 +1517,9 @@ SWGChannelSettings::isSet(){
         if(free_dv_mod_settings && free_dv_mod_settings->isSet()){
             isObjectUpdated = true; break;
         }
+        if(freq_scanner_settings && freq_scanner_settings->isSet()){
+            isObjectUpdated = true; break;
+        }
         if(freq_tracker_settings && freq_tracker_settings->isSet()){
             isObjectUpdated = true; break;
         }
diff --git a/swagger/sdrangel/code/qt5/client/SWGChannelSettings.h b/swagger/sdrangel/code/qt5/client/SWGChannelSettings.h
index 9f652b0dd..6749bfff8 100644
--- a/swagger/sdrangel/code/qt5/client/SWGChannelSettings.h
+++ b/swagger/sdrangel/code/qt5/client/SWGChannelSettings.h
@@ -46,6 +46,7 @@
 #include "SWGFileSourceSettings.h"
 #include "SWGFreeDVDemodSettings.h"
 #include "SWGFreeDVModSettings.h"
+#include "SWGFreqScannerSettings.h"
 #include "SWGFreqTrackerSettings.h"
 #include "SWGHeatMapSettings.h"
 #include "SWGIEEE_802_15_4_ModSettings.h"
@@ -180,6 +181,9 @@ public:
     SWGFreeDVModSettings* getFreeDvModSettings();
     void setFreeDvModSettings(SWGFreeDVModSettings* free_dv_mod_settings);
 
+    SWGFreqScannerSettings* getFreqScannerSettings();
+    void setFreqScannerSettings(SWGFreqScannerSettings* freq_scanner_settings);
+
     SWGFreqTrackerSettings* getFreqTrackerSettings();
     void setFreqTrackerSettings(SWGFreqTrackerSettings* freq_tracker_settings);
 
@@ -367,6 +371,9 @@ private:
     SWGFreeDVModSettings* free_dv_mod_settings;
     bool m_free_dv_mod_settings_isSet;
 
+    SWGFreqScannerSettings* freq_scanner_settings;
+    bool m_freq_scanner_settings_isSet;
+
     SWGFreqTrackerSettings* freq_tracker_settings;
     bool m_freq_tracker_settings_isSet;
 
diff --git a/swagger/sdrangel/code/qt5/client/SWGFreqScannerReport.cpp b/swagger/sdrangel/code/qt5/client/SWGFreqScannerReport.cpp
new file mode 100644
index 000000000..13c29211d
--- /dev/null
+++ b/swagger/sdrangel/code/qt5/client/SWGFreqScannerReport.cpp
@@ -0,0 +1,108 @@
+/**
+ * SDRangel
+ * This is the web REST/JSON API of SDRangel SDR software. SDRangel is an Open Source Qt5/OpenGL 3.0+ (4.3+ in Windows) GUI and server Software Defined Radio and signal analyzer in software. It supports Airspy, BladeRF, HackRF, LimeSDR, PlutoSDR, RTL-SDR, SDRplay RSP1 and FunCube    ---   Limitations and specifcities:    * In SDRangel GUI the first Rx device set cannot be deleted. Conversely the server starts with no device sets and its number of device sets can be reduced to zero by as many calls as necessary to /sdrangel/deviceset with DELETE method.   * Preset import and export from/to file is a server only feature.   * Device set focus is a GUI only feature.   * The following channels are not implemented (status 501 is returned): ATV and DATV demodulators, Channel Analyzer NG, LoRa demodulator   * The device settings and report structures contains only the sub-structure corresponding to the device type. The DeviceSettings and DeviceReport structures documented here shows all of them but only one will be or should be present at a time   * The channel settings and report structures contains only the sub-structure corresponding to the channel type. The ChannelSettings and ChannelReport structures documented here shows all of them but only one will be or should be present at a time    --- 
+ *
+ * OpenAPI spec version: 7.0.0
+ * Contact: f4exb06@gmail.com
+ *
+ * NOTE: This class is auto generated by the swagger code generator program.
+ * https://github.com/swagger-api/swagger-codegen.git
+ * Do not edit the class manually.
+ */
+
+
+#include "SWGFreqScannerReport.h"
+
+#include "SWGHelpers.h"
+
+#include <QJsonDocument>
+#include <QJsonArray>
+#include <QObject>
+#include <QDebug>
+
+namespace SWGSDRangel {
+
+SWGFreqScannerReport::SWGFreqScannerReport(QString* json) {
+    init();
+    this->fromJson(*json);
+}
+
+SWGFreqScannerReport::SWGFreqScannerReport() {
+    channel_sample_rate = 0;
+    m_channel_sample_rate_isSet = false;
+}
+
+SWGFreqScannerReport::~SWGFreqScannerReport() {
+    this->cleanup();
+}
+
+void
+SWGFreqScannerReport::init() {
+    channel_sample_rate = 0;
+    m_channel_sample_rate_isSet = false;
+}
+
+void
+SWGFreqScannerReport::cleanup() {
+
+}
+
+SWGFreqScannerReport*
+SWGFreqScannerReport::fromJson(QString &json) {
+    QByteArray array (json.toStdString().c_str());
+    QJsonDocument doc = QJsonDocument::fromJson(array);
+    QJsonObject jsonObject = doc.object();
+    this->fromJsonObject(jsonObject);
+    return this;
+}
+
+void
+SWGFreqScannerReport::fromJsonObject(QJsonObject &pJson) {
+    ::SWGSDRangel::setValue(&channel_sample_rate, pJson["channelSampleRate"], "qint32", "");
+    
+}
+
+QString
+SWGFreqScannerReport::asJson ()
+{
+    QJsonObject* obj = this->asJsonObject();
+
+    QJsonDocument doc(*obj);
+    QByteArray bytes = doc.toJson();
+    delete obj;
+    return QString(bytes);
+}
+
+QJsonObject*
+SWGFreqScannerReport::asJsonObject() {
+    QJsonObject* obj = new QJsonObject();
+    if(m_channel_sample_rate_isSet){
+        obj->insert("channelSampleRate", QJsonValue(channel_sample_rate));
+    }
+
+    return obj;
+}
+
+qint32
+SWGFreqScannerReport::getChannelSampleRate() {
+    return channel_sample_rate;
+}
+void
+SWGFreqScannerReport::setChannelSampleRate(qint32 channel_sample_rate) {
+    this->channel_sample_rate = channel_sample_rate;
+    this->m_channel_sample_rate_isSet = true;
+}
+
+
+bool
+SWGFreqScannerReport::isSet(){
+    bool isObjectUpdated = false;
+    do{
+        if(m_channel_sample_rate_isSet){
+            isObjectUpdated = true; break;
+        }
+    }while(false);
+    return isObjectUpdated;
+}
+}
+
diff --git a/swagger/sdrangel/code/qt5/client/SWGFreqScannerReport.h b/swagger/sdrangel/code/qt5/client/SWGFreqScannerReport.h
new file mode 100644
index 000000000..2c669ecff
--- /dev/null
+++ b/swagger/sdrangel/code/qt5/client/SWGFreqScannerReport.h
@@ -0,0 +1,58 @@
+/**
+ * SDRangel
+ * This is the web REST/JSON API of SDRangel SDR software. SDRangel is an Open Source Qt5/OpenGL 3.0+ (4.3+ in Windows) GUI and server Software Defined Radio and signal analyzer in software. It supports Airspy, BladeRF, HackRF, LimeSDR, PlutoSDR, RTL-SDR, SDRplay RSP1 and FunCube    ---   Limitations and specifcities:    * In SDRangel GUI the first Rx device set cannot be deleted. Conversely the server starts with no device sets and its number of device sets can be reduced to zero by as many calls as necessary to /sdrangel/deviceset with DELETE method.   * Preset import and export from/to file is a server only feature.   * Device set focus is a GUI only feature.   * The following channels are not implemented (status 501 is returned): ATV and DATV demodulators, Channel Analyzer NG, LoRa demodulator   * The device settings and report structures contains only the sub-structure corresponding to the device type. The DeviceSettings and DeviceReport structures documented here shows all of them but only one will be or should be present at a time   * The channel settings and report structures contains only the sub-structure corresponding to the channel type. The ChannelSettings and ChannelReport structures documented here shows all of them but only one will be or should be present at a time    --- 
+ *
+ * OpenAPI spec version: 7.0.0
+ * Contact: f4exb06@gmail.com
+ *
+ * NOTE: This class is auto generated by the swagger code generator program.
+ * https://github.com/swagger-api/swagger-codegen.git
+ * Do not edit the class manually.
+ */
+
+/*
+ * SWGFreqScannerReport.h
+ *
+ * FreqScanner
+ */
+
+#ifndef SWGFreqScannerReport_H_
+#define SWGFreqScannerReport_H_
+
+#include <QJsonObject>
+
+
+
+#include "SWGObject.h"
+#include "export.h"
+
+namespace SWGSDRangel {
+
+class SWG_API SWGFreqScannerReport: public SWGObject {
+public:
+    SWGFreqScannerReport();
+    SWGFreqScannerReport(QString* json);
+    virtual ~SWGFreqScannerReport();
+    void init();
+    void cleanup();
+
+    virtual QString asJson () override;
+    virtual QJsonObject* asJsonObject() override;
+    virtual void fromJsonObject(QJsonObject &json) override;
+    virtual SWGFreqScannerReport* fromJson(QString &jsonString) override;
+
+    qint32 getChannelSampleRate();
+    void setChannelSampleRate(qint32 channel_sample_rate);
+
+
+    virtual bool isSet() override;
+
+private:
+    qint32 channel_sample_rate;
+    bool m_channel_sample_rate_isSet;
+
+};
+
+}
+
+#endif /* SWGFreqScannerReport_H_ */
diff --git a/swagger/sdrangel/code/qt5/client/SWGFreqScannerSettings.cpp b/swagger/sdrangel/code/qt5/client/SWGFreqScannerSettings.cpp
new file mode 100644
index 000000000..f850678c2
--- /dev/null
+++ b/swagger/sdrangel/code/qt5/client/SWGFreqScannerSettings.cpp
@@ -0,0 +1,636 @@
+/**
+ * SDRangel
+ * This is the web REST/JSON API of SDRangel SDR software. SDRangel is an Open Source Qt5/OpenGL 3.0+ (4.3+ in Windows) GUI and server Software Defined Radio and signal analyzer in software. It supports Airspy, BladeRF, HackRF, LimeSDR, PlutoSDR, RTL-SDR, SDRplay RSP1 and FunCube    ---   Limitations and specifcities:    * In SDRangel GUI the first Rx device set cannot be deleted. Conversely the server starts with no device sets and its number of device sets can be reduced to zero by as many calls as necessary to /sdrangel/deviceset with DELETE method.   * Preset import and export from/to file is a server only feature.   * Device set focus is a GUI only feature.   * The following channels are not implemented (status 501 is returned): ATV and DATV demodulators, Channel Analyzer NG, LoRa demodulator   * The device settings and report structures contains only the sub-structure corresponding to the device type. The DeviceSettings and DeviceReport structures documented here shows all of them but only one will be or should be present at a time   * The channel settings and report structures contains only the sub-structure corresponding to the channel type. The ChannelSettings and ChannelReport structures documented here shows all of them but only one will be or should be present at a time    --- 
+ *
+ * OpenAPI spec version: 7.0.0
+ * Contact: f4exb06@gmail.com
+ *
+ * NOTE: This class is auto generated by the swagger code generator program.
+ * https://github.com/swagger-api/swagger-codegen.git
+ * Do not edit the class manually.
+ */
+
+
+#include "SWGFreqScannerSettings.h"
+
+#include "SWGHelpers.h"
+
+#include <QJsonDocument>
+#include <QJsonArray>
+#include <QObject>
+#include <QDebug>
+
+namespace SWGSDRangel {
+
+SWGFreqScannerSettings::SWGFreqScannerSettings(QString* json) {
+    init();
+    this->fromJson(*json);
+}
+
+SWGFreqScannerSettings::SWGFreqScannerSettings() {
+    channel_bandwidth = 0;
+    m_channel_bandwidth_isSet = false;
+    channel_frequency_offset = 0;
+    m_channel_frequency_offset_isSet = false;
+    threshold = 0.0f;
+    m_threshold_isSet = false;
+    m_frequencies = new QList<qint64>();
+    m_m_frequencies_isSet = false;
+    m_enabled = new QList<qint32>();
+    m_m_enabled_isSet = false;
+    m_notes = nullptr;
+    m_m_notes_isSet = false;
+    channel = nullptr;
+    m_channel_isSet = false;
+    scan_time = 0.0f;
+    m_scan_time_isSet = false;
+    retransmit_time = 0.0f;
+    m_retransmit_time_isSet = false;
+    tune_time = 0.0f;
+    m_tune_time_isSet = false;
+    priority = 0;
+    m_priority_isSet = false;
+    measurement = 0;
+    m_measurement_isSet = false;
+    mode = 0;
+    m_mode_isSet = false;
+    rgb_color = 0;
+    m_rgb_color_isSet = false;
+    title = nullptr;
+    m_title_isSet = false;
+    stream_index = 0;
+    m_stream_index_isSet = false;
+    use_reverse_api = 0;
+    m_use_reverse_api_isSet = false;
+    reverse_api_address = nullptr;
+    m_reverse_api_address_isSet = false;
+    reverse_api_port = 0;
+    m_reverse_api_port_isSet = false;
+    reverse_api_device_index = 0;
+    m_reverse_api_device_index_isSet = false;
+    reverse_api_channel_index = 0;
+    m_reverse_api_channel_index_isSet = false;
+    channel_marker = nullptr;
+    m_channel_marker_isSet = false;
+    rollup_state = nullptr;
+    m_rollup_state_isSet = false;
+}
+
+SWGFreqScannerSettings::~SWGFreqScannerSettings() {
+    this->cleanup();
+}
+
+void
+SWGFreqScannerSettings::init() {
+    channel_bandwidth = 0;
+    m_channel_bandwidth_isSet = false;
+    channel_frequency_offset = 0;
+    m_channel_frequency_offset_isSet = false;
+    threshold = 0.0f;
+    m_threshold_isSet = false;
+    m_frequencies = new QList<qint64>();
+    m_m_frequencies_isSet = false;
+    m_enabled = new QList<qint32>();
+    m_m_enabled_isSet = false;
+    m_notes = new QList<QString*>();
+    m_m_notes_isSet = false;
+    channel = new QString("");
+    m_channel_isSet = false;
+    scan_time = 0.0f;
+    m_scan_time_isSet = false;
+    retransmit_time = 0.0f;
+    m_retransmit_time_isSet = false;
+    tune_time = 0.0f;
+    m_tune_time_isSet = false;
+    priority = 0;
+    m_priority_isSet = false;
+    measurement = 0;
+    m_measurement_isSet = false;
+    mode = 0;
+    m_mode_isSet = false;
+    rgb_color = 0;
+    m_rgb_color_isSet = false;
+    title = new QString("");
+    m_title_isSet = false;
+    stream_index = 0;
+    m_stream_index_isSet = false;
+    use_reverse_api = 0;
+    m_use_reverse_api_isSet = false;
+    reverse_api_address = new QString("");
+    m_reverse_api_address_isSet = false;
+    reverse_api_port = 0;
+    m_reverse_api_port_isSet = false;
+    reverse_api_device_index = 0;
+    m_reverse_api_device_index_isSet = false;
+    reverse_api_channel_index = 0;
+    m_reverse_api_channel_index_isSet = false;
+    channel_marker = new SWGChannelMarker();
+    m_channel_marker_isSet = false;
+    rollup_state = new SWGRollupState();
+    m_rollup_state_isSet = false;
+}
+
+void
+SWGFreqScannerSettings::cleanup() {
+
+
+
+
+
+    if(m_notes != nullptr) { 
+        auto arr = m_notes;
+        for(auto o: *arr) { 
+            delete o;
+        }
+        delete m_notes;
+    }
+    if(channel != nullptr) { 
+        delete channel;
+    }
+
+
+
+
+
+
+
+    if(title != nullptr) { 
+        delete title;
+    }
+
+
+    if(reverse_api_address != nullptr) { 
+        delete reverse_api_address;
+    }
+
+
+
+    if(channel_marker != nullptr) { 
+        delete channel_marker;
+    }
+    if(rollup_state != nullptr) { 
+        delete rollup_state;
+    }
+}
+
+SWGFreqScannerSettings*
+SWGFreqScannerSettings::fromJson(QString &json) {
+    QByteArray array (json.toStdString().c_str());
+    QJsonDocument doc = QJsonDocument::fromJson(array);
+    QJsonObject jsonObject = doc.object();
+    this->fromJsonObject(jsonObject);
+    return this;
+}
+
+void
+SWGFreqScannerSettings::fromJsonObject(QJsonObject &pJson) {
+    ::SWGSDRangel::setValue(&channel_bandwidth, pJson["channelBandwidth"], "qint32", "");
+    
+    ::SWGSDRangel::setValue(&channel_frequency_offset, pJson["channelFrequencyOffset"], "qint32", "");
+    
+    ::SWGSDRangel::setValue(&threshold, pJson["threshold"], "float", "");
+    
+    
+    ::SWGSDRangel::setValue(&m_frequencies, pJson["m_frequencies"], "QList", "qint64");
+    
+    ::SWGSDRangel::setValue(&m_enabled, pJson["m_enabled"], "QList", "qint32");
+    
+    ::SWGSDRangel::setValue(&m_notes, pJson["m_notes"], "QList", "QString");
+    ::SWGSDRangel::setValue(&channel, pJson["channel"], "QString", "QString");
+    
+    ::SWGSDRangel::setValue(&scan_time, pJson["scanTime"], "float", "");
+    
+    ::SWGSDRangel::setValue(&retransmit_time, pJson["retransmitTime"], "float", "");
+    
+    ::SWGSDRangel::setValue(&tune_time, pJson["tuneTime"], "float", "");
+    
+    ::SWGSDRangel::setValue(&priority, pJson["priority"], "qint32", "");
+    
+    ::SWGSDRangel::setValue(&measurement, pJson["measurement"], "qint32", "");
+    
+    ::SWGSDRangel::setValue(&mode, pJson["mode"], "qint32", "");
+    
+    ::SWGSDRangel::setValue(&rgb_color, pJson["rgbColor"], "qint32", "");
+    
+    ::SWGSDRangel::setValue(&title, pJson["title"], "QString", "QString");
+    
+    ::SWGSDRangel::setValue(&stream_index, pJson["streamIndex"], "qint32", "");
+    
+    ::SWGSDRangel::setValue(&use_reverse_api, pJson["useReverseAPI"], "qint32", "");
+    
+    ::SWGSDRangel::setValue(&reverse_api_address, pJson["reverseAPIAddress"], "QString", "QString");
+    
+    ::SWGSDRangel::setValue(&reverse_api_port, pJson["reverseAPIPort"], "qint32", "");
+    
+    ::SWGSDRangel::setValue(&reverse_api_device_index, pJson["reverseAPIDeviceIndex"], "qint32", "");
+    
+    ::SWGSDRangel::setValue(&reverse_api_channel_index, pJson["reverseAPIChannelIndex"], "qint32", "");
+    
+    ::SWGSDRangel::setValue(&channel_marker, pJson["channelMarker"], "SWGChannelMarker", "SWGChannelMarker");
+    
+    ::SWGSDRangel::setValue(&rollup_state, pJson["rollupState"], "SWGRollupState", "SWGRollupState");
+    
+}
+
+QString
+SWGFreqScannerSettings::asJson ()
+{
+    QJsonObject* obj = this->asJsonObject();
+
+    QJsonDocument doc(*obj);
+    QByteArray bytes = doc.toJson();
+    delete obj;
+    return QString(bytes);
+}
+
+QJsonObject*
+SWGFreqScannerSettings::asJsonObject() {
+    QJsonObject* obj = new QJsonObject();
+    if(m_channel_bandwidth_isSet){
+        obj->insert("channelBandwidth", QJsonValue(channel_bandwidth));
+    }
+    if(m_channel_frequency_offset_isSet){
+        obj->insert("channelFrequencyOffset", QJsonValue(channel_frequency_offset));
+    }
+    if(m_threshold_isSet){
+        obj->insert("threshold", QJsonValue(threshold));
+    }
+    if(m_frequencies && m_frequencies->size() > 0){
+        toJsonArray((QList<void*>*)m_frequencies, obj, "m_frequencies", "");
+    }
+    if(m_enabled && m_enabled->size() > 0){
+        toJsonArray((QList<void*>*)m_enabled, obj, "m_enabled", "");
+    }
+    if(m_notes && m_notes->size() > 0){
+        toJsonArray((QList<void*>*)m_notes, obj, "m_notes", "QString");
+    }
+    if(channel != nullptr && *channel != QString("")){
+        toJsonValue(QString("channel"), channel, obj, QString("QString"));
+    }
+    if(m_scan_time_isSet){
+        obj->insert("scanTime", QJsonValue(scan_time));
+    }
+    if(m_retransmit_time_isSet){
+        obj->insert("retransmitTime", QJsonValue(retransmit_time));
+    }
+    if(m_tune_time_isSet){
+        obj->insert("tuneTime", QJsonValue(tune_time));
+    }
+    if(m_priority_isSet){
+        obj->insert("priority", QJsonValue(priority));
+    }
+    if(m_measurement_isSet){
+        obj->insert("measurement", QJsonValue(measurement));
+    }
+    if(m_mode_isSet){
+        obj->insert("mode", QJsonValue(mode));
+    }
+    if(m_rgb_color_isSet){
+        obj->insert("rgbColor", QJsonValue(rgb_color));
+    }
+    if(title != nullptr && *title != QString("")){
+        toJsonValue(QString("title"), title, obj, QString("QString"));
+    }
+    if(m_stream_index_isSet){
+        obj->insert("streamIndex", QJsonValue(stream_index));
+    }
+    if(m_use_reverse_api_isSet){
+        obj->insert("useReverseAPI", QJsonValue(use_reverse_api));
+    }
+    if(reverse_api_address != nullptr && *reverse_api_address != QString("")){
+        toJsonValue(QString("reverseAPIAddress"), reverse_api_address, obj, QString("QString"));
+    }
+    if(m_reverse_api_port_isSet){
+        obj->insert("reverseAPIPort", QJsonValue(reverse_api_port));
+    }
+    if(m_reverse_api_device_index_isSet){
+        obj->insert("reverseAPIDeviceIndex", QJsonValue(reverse_api_device_index));
+    }
+    if(m_reverse_api_channel_index_isSet){
+        obj->insert("reverseAPIChannelIndex", QJsonValue(reverse_api_channel_index));
+    }
+    if((channel_marker != nullptr) && (channel_marker->isSet())){
+        toJsonValue(QString("channelMarker"), channel_marker, obj, QString("SWGChannelMarker"));
+    }
+    if((rollup_state != nullptr) && (rollup_state->isSet())){
+        toJsonValue(QString("rollupState"), rollup_state, obj, QString("SWGRollupState"));
+    }
+
+    return obj;
+}
+
+qint32
+SWGFreqScannerSettings::getChannelBandwidth() {
+    return channel_bandwidth;
+}
+void
+SWGFreqScannerSettings::setChannelBandwidth(qint32 channel_bandwidth) {
+    this->channel_bandwidth = channel_bandwidth;
+    this->m_channel_bandwidth_isSet = true;
+}
+
+qint32
+SWGFreqScannerSettings::getChannelFrequencyOffset() {
+    return channel_frequency_offset;
+}
+void
+SWGFreqScannerSettings::setChannelFrequencyOffset(qint32 channel_frequency_offset) {
+    this->channel_frequency_offset = channel_frequency_offset;
+    this->m_channel_frequency_offset_isSet = true;
+}
+
+float
+SWGFreqScannerSettings::getThreshold() {
+    return threshold;
+}
+void
+SWGFreqScannerSettings::setThreshold(float threshold) {
+    this->threshold = threshold;
+    this->m_threshold_isSet = true;
+}
+
+QList<qint64>*
+SWGFreqScannerSettings::getMFrequencies() {
+    return m_frequencies;
+}
+void
+SWGFreqScannerSettings::setMFrequencies(QList<qint64>* m_frequencies) {
+    this->m_frequencies = m_frequencies;
+    this->m_m_frequencies_isSet = true;
+}
+
+QList<qint32>*
+SWGFreqScannerSettings::getMEnabled() {
+    return m_enabled;
+}
+void
+SWGFreqScannerSettings::setMEnabled(QList<qint32>* m_enabled) {
+    this->m_enabled = m_enabled;
+    this->m_m_enabled_isSet = true;
+}
+
+QList<QString*>*
+SWGFreqScannerSettings::getMNotes() {
+    return m_notes;
+}
+void
+SWGFreqScannerSettings::setMNotes(QList<QString*>* m_notes) {
+    this->m_notes = m_notes;
+    this->m_m_notes_isSet = true;
+}
+
+QString*
+SWGFreqScannerSettings::getChannel() {
+    return channel;
+}
+void
+SWGFreqScannerSettings::setChannel(QString* channel) {
+    this->channel = channel;
+    this->m_channel_isSet = true;
+}
+
+float
+SWGFreqScannerSettings::getScanTime() {
+    return scan_time;
+}
+void
+SWGFreqScannerSettings::setScanTime(float scan_time) {
+    this->scan_time = scan_time;
+    this->m_scan_time_isSet = true;
+}
+
+float
+SWGFreqScannerSettings::getRetransmitTime() {
+    return retransmit_time;
+}
+void
+SWGFreqScannerSettings::setRetransmitTime(float retransmit_time) {
+    this->retransmit_time = retransmit_time;
+    this->m_retransmit_time_isSet = true;
+}
+
+float
+SWGFreqScannerSettings::getTuneTime() {
+    return tune_time;
+}
+void
+SWGFreqScannerSettings::setTuneTime(float tune_time) {
+    this->tune_time = tune_time;
+    this->m_tune_time_isSet = true;
+}
+
+qint32
+SWGFreqScannerSettings::getPriority() {
+    return priority;
+}
+void
+SWGFreqScannerSettings::setPriority(qint32 priority) {
+    this->priority = priority;
+    this->m_priority_isSet = true;
+}
+
+qint32
+SWGFreqScannerSettings::getMeasurement() {
+    return measurement;
+}
+void
+SWGFreqScannerSettings::setMeasurement(qint32 measurement) {
+    this->measurement = measurement;
+    this->m_measurement_isSet = true;
+}
+
+qint32
+SWGFreqScannerSettings::getMode() {
+    return mode;
+}
+void
+SWGFreqScannerSettings::setMode(qint32 mode) {
+    this->mode = mode;
+    this->m_mode_isSet = true;
+}
+
+qint32
+SWGFreqScannerSettings::getRgbColor() {
+    return rgb_color;
+}
+void
+SWGFreqScannerSettings::setRgbColor(qint32 rgb_color) {
+    this->rgb_color = rgb_color;
+    this->m_rgb_color_isSet = true;
+}
+
+QString*
+SWGFreqScannerSettings::getTitle() {
+    return title;
+}
+void
+SWGFreqScannerSettings::setTitle(QString* title) {
+    this->title = title;
+    this->m_title_isSet = true;
+}
+
+qint32
+SWGFreqScannerSettings::getStreamIndex() {
+    return stream_index;
+}
+void
+SWGFreqScannerSettings::setStreamIndex(qint32 stream_index) {
+    this->stream_index = stream_index;
+    this->m_stream_index_isSet = true;
+}
+
+qint32
+SWGFreqScannerSettings::getUseReverseApi() {
+    return use_reverse_api;
+}
+void
+SWGFreqScannerSettings::setUseReverseApi(qint32 use_reverse_api) {
+    this->use_reverse_api = use_reverse_api;
+    this->m_use_reverse_api_isSet = true;
+}
+
+QString*
+SWGFreqScannerSettings::getReverseApiAddress() {
+    return reverse_api_address;
+}
+void
+SWGFreqScannerSettings::setReverseApiAddress(QString* reverse_api_address) {
+    this->reverse_api_address = reverse_api_address;
+    this->m_reverse_api_address_isSet = true;
+}
+
+qint32
+SWGFreqScannerSettings::getReverseApiPort() {
+    return reverse_api_port;
+}
+void
+SWGFreqScannerSettings::setReverseApiPort(qint32 reverse_api_port) {
+    this->reverse_api_port = reverse_api_port;
+    this->m_reverse_api_port_isSet = true;
+}
+
+qint32
+SWGFreqScannerSettings::getReverseApiDeviceIndex() {
+    return reverse_api_device_index;
+}
+void
+SWGFreqScannerSettings::setReverseApiDeviceIndex(qint32 reverse_api_device_index) {
+    this->reverse_api_device_index = reverse_api_device_index;
+    this->m_reverse_api_device_index_isSet = true;
+}
+
+qint32
+SWGFreqScannerSettings::getReverseApiChannelIndex() {
+    return reverse_api_channel_index;
+}
+void
+SWGFreqScannerSettings::setReverseApiChannelIndex(qint32 reverse_api_channel_index) {
+    this->reverse_api_channel_index = reverse_api_channel_index;
+    this->m_reverse_api_channel_index_isSet = true;
+}
+
+SWGChannelMarker*
+SWGFreqScannerSettings::getChannelMarker() {
+    return channel_marker;
+}
+void
+SWGFreqScannerSettings::setChannelMarker(SWGChannelMarker* channel_marker) {
+    this->channel_marker = channel_marker;
+    this->m_channel_marker_isSet = true;
+}
+
+SWGRollupState*
+SWGFreqScannerSettings::getRollupState() {
+    return rollup_state;
+}
+void
+SWGFreqScannerSettings::setRollupState(SWGRollupState* rollup_state) {
+    this->rollup_state = rollup_state;
+    this->m_rollup_state_isSet = true;
+}
+
+
+bool
+SWGFreqScannerSettings::isSet(){
+    bool isObjectUpdated = false;
+    do{
+        if(m_channel_bandwidth_isSet){
+            isObjectUpdated = true; break;
+        }
+        if(m_channel_frequency_offset_isSet){
+            isObjectUpdated = true; break;
+        }
+        if(m_threshold_isSet){
+            isObjectUpdated = true; break;
+        }
+        if(m_m_frequencies_isSet){
+            isObjectUpdated = true; break;
+        }
+        if(m_frequencies && (m_frequencies->size() > 0)){
+            isObjectUpdated = true; break;
+        }
+        if(m_m_enabled_isSet){
+            isObjectUpdated = true; break;
+        }
+        if(m_enabled && (m_enabled->size() > 0)){
+            isObjectUpdated = true; break;
+        }
+        if(m_notes && (m_notes->size() > 0)){
+            isObjectUpdated = true; break;
+        }
+        if(channel && *channel != QString("")){
+            isObjectUpdated = true; break;
+        }
+        if(m_scan_time_isSet){
+            isObjectUpdated = true; break;
+        }
+        if(m_retransmit_time_isSet){
+            isObjectUpdated = true; break;
+        }
+        if(m_tune_time_isSet){
+            isObjectUpdated = true; break;
+        }
+        if(m_priority_isSet){
+            isObjectUpdated = true; break;
+        }
+        if(m_measurement_isSet){
+            isObjectUpdated = true; break;
+        }
+        if(m_mode_isSet){
+            isObjectUpdated = true; break;
+        }
+        if(m_rgb_color_isSet){
+            isObjectUpdated = true; break;
+        }
+        if(title && *title != QString("")){
+            isObjectUpdated = true; break;
+        }
+        if(m_stream_index_isSet){
+            isObjectUpdated = true; break;
+        }
+        if(m_use_reverse_api_isSet){
+            isObjectUpdated = true; break;
+        }
+        if(reverse_api_address && *reverse_api_address != QString("")){
+            isObjectUpdated = true; break;
+        }
+        if(m_reverse_api_port_isSet){
+            isObjectUpdated = true; break;
+        }
+        if(m_reverse_api_device_index_isSet){
+            isObjectUpdated = true; break;
+        }
+        if(m_reverse_api_channel_index_isSet){
+            isObjectUpdated = true; break;
+        }
+        if(channel_marker && channel_marker->isSet()){
+            isObjectUpdated = true; break;
+        }
+        if(rollup_state && rollup_state->isSet()){
+            isObjectUpdated = true; break;
+        }
+    }while(false);
+    return isObjectUpdated;
+}
+}
+
diff --git a/swagger/sdrangel/code/qt5/client/SWGFreqScannerSettings.h b/swagger/sdrangel/code/qt5/client/SWGFreqScannerSettings.h
new file mode 100644
index 000000000..a166b027b
--- /dev/null
+++ b/swagger/sdrangel/code/qt5/client/SWGFreqScannerSettings.h
@@ -0,0 +1,194 @@
+/**
+ * SDRangel
+ * This is the web REST/JSON API of SDRangel SDR software. SDRangel is an Open Source Qt5/OpenGL 3.0+ (4.3+ in Windows) GUI and server Software Defined Radio and signal analyzer in software. It supports Airspy, BladeRF, HackRF, LimeSDR, PlutoSDR, RTL-SDR, SDRplay RSP1 and FunCube    ---   Limitations and specifcities:    * In SDRangel GUI the first Rx device set cannot be deleted. Conversely the server starts with no device sets and its number of device sets can be reduced to zero by as many calls as necessary to /sdrangel/deviceset with DELETE method.   * Preset import and export from/to file is a server only feature.   * Device set focus is a GUI only feature.   * The following channels are not implemented (status 501 is returned): ATV and DATV demodulators, Channel Analyzer NG, LoRa demodulator   * The device settings and report structures contains only the sub-structure corresponding to the device type. The DeviceSettings and DeviceReport structures documented here shows all of them but only one will be or should be present at a time   * The channel settings and report structures contains only the sub-structure corresponding to the channel type. The ChannelSettings and ChannelReport structures documented here shows all of them but only one will be or should be present at a time    --- 
+ *
+ * OpenAPI spec version: 7.0.0
+ * Contact: f4exb06@gmail.com
+ *
+ * NOTE: This class is auto generated by the swagger code generator program.
+ * https://github.com/swagger-api/swagger-codegen.git
+ * Do not edit the class manually.
+ */
+
+/*
+ * SWGFreqScannerSettings.h
+ *
+ * FreqScanner
+ */
+
+#ifndef SWGFreqScannerSettings_H_
+#define SWGFreqScannerSettings_H_
+
+#include <QJsonObject>
+
+
+#include "SWGChannelMarker.h"
+#include "SWGRollupState.h"
+#include <QList>
+#include <QString>
+
+#include "SWGObject.h"
+#include "export.h"
+
+namespace SWGSDRangel {
+
+class SWG_API SWGFreqScannerSettings: public SWGObject {
+public:
+    SWGFreqScannerSettings();
+    SWGFreqScannerSettings(QString* json);
+    virtual ~SWGFreqScannerSettings();
+    void init();
+    void cleanup();
+
+    virtual QString asJson () override;
+    virtual QJsonObject* asJsonObject() override;
+    virtual void fromJsonObject(QJsonObject &json) override;
+    virtual SWGFreqScannerSettings* fromJson(QString &jsonString) override;
+
+    qint32 getChannelBandwidth();
+    void setChannelBandwidth(qint32 channel_bandwidth);
+
+    qint32 getChannelFrequencyOffset();
+    void setChannelFrequencyOffset(qint32 channel_frequency_offset);
+
+    float getThreshold();
+    void setThreshold(float threshold);
+
+    QList<qint64>* getMFrequencies();
+    void setMFrequencies(QList<qint64>* m_frequencies);
+
+    QList<qint32>* getMEnabled();
+    void setMEnabled(QList<qint32>* m_enabled);
+
+    QList<QString*>* getMNotes();
+    void setMNotes(QList<QString*>* m_notes);
+
+    QString* getChannel();
+    void setChannel(QString* channel);
+
+    float getScanTime();
+    void setScanTime(float scan_time);
+
+    float getRetransmitTime();
+    void setRetransmitTime(float retransmit_time);
+
+    float getTuneTime();
+    void setTuneTime(float tune_time);
+
+    qint32 getPriority();
+    void setPriority(qint32 priority);
+
+    qint32 getMeasurement();
+    void setMeasurement(qint32 measurement);
+
+    qint32 getMode();
+    void setMode(qint32 mode);
+
+    qint32 getRgbColor();
+    void setRgbColor(qint32 rgb_color);
+
+    QString* getTitle();
+    void setTitle(QString* title);
+
+    qint32 getStreamIndex();
+    void setStreamIndex(qint32 stream_index);
+
+    qint32 getUseReverseApi();
+    void setUseReverseApi(qint32 use_reverse_api);
+
+    QString* getReverseApiAddress();
+    void setReverseApiAddress(QString* reverse_api_address);
+
+    qint32 getReverseApiPort();
+    void setReverseApiPort(qint32 reverse_api_port);
+
+    qint32 getReverseApiDeviceIndex();
+    void setReverseApiDeviceIndex(qint32 reverse_api_device_index);
+
+    qint32 getReverseApiChannelIndex();
+    void setReverseApiChannelIndex(qint32 reverse_api_channel_index);
+
+    SWGChannelMarker* getChannelMarker();
+    void setChannelMarker(SWGChannelMarker* channel_marker);
+
+    SWGRollupState* getRollupState();
+    void setRollupState(SWGRollupState* rollup_state);
+
+
+    virtual bool isSet() override;
+
+private:
+    qint32 channel_bandwidth;
+    bool m_channel_bandwidth_isSet;
+
+    qint32 channel_frequency_offset;
+    bool m_channel_frequency_offset_isSet;
+
+    float threshold;
+    bool m_threshold_isSet;
+
+    QList<qint64>* m_frequencies;
+    bool m_m_frequencies_isSet;
+
+    QList<qint32>* m_enabled;
+    bool m_m_enabled_isSet;
+
+    QList<QString*>* m_notes;
+    bool m_m_notes_isSet;
+
+    QString* channel;
+    bool m_channel_isSet;
+
+    float scan_time;
+    bool m_scan_time_isSet;
+
+    float retransmit_time;
+    bool m_retransmit_time_isSet;
+
+    float tune_time;
+    bool m_tune_time_isSet;
+
+    qint32 priority;
+    bool m_priority_isSet;
+
+    qint32 measurement;
+    bool m_measurement_isSet;
+
+    qint32 mode;
+    bool m_mode_isSet;
+
+    qint32 rgb_color;
+    bool m_rgb_color_isSet;
+
+    QString* title;
+    bool m_title_isSet;
+
+    qint32 stream_index;
+    bool m_stream_index_isSet;
+
+    qint32 use_reverse_api;
+    bool m_use_reverse_api_isSet;
+
+    QString* reverse_api_address;
+    bool m_reverse_api_address_isSet;
+
+    qint32 reverse_api_port;
+    bool m_reverse_api_port_isSet;
+
+    qint32 reverse_api_device_index;
+    bool m_reverse_api_device_index_isSet;
+
+    qint32 reverse_api_channel_index;
+    bool m_reverse_api_channel_index_isSet;
+
+    SWGChannelMarker* channel_marker;
+    bool m_channel_marker_isSet;
+
+    SWGRollupState* rollup_state;
+    bool m_rollup_state_isSet;
+
+};
+
+}
+
+#endif /* SWGFreqScannerSettings_H_ */
diff --git a/swagger/sdrangel/code/qt5/client/SWGModelFactory.h b/swagger/sdrangel/code/qt5/client/SWGModelFactory.h
index d830fba9b..f2ea14a39 100644
--- a/swagger/sdrangel/code/qt5/client/SWGModelFactory.h
+++ b/swagger/sdrangel/code/qt5/client/SWGModelFactory.h
@@ -151,6 +151,8 @@
 #include "SWGFreeDVDemodSettings.h"
 #include "SWGFreeDVModReport.h"
 #include "SWGFreeDVModSettings.h"
+#include "SWGFreqScannerReport.h"
+#include "SWGFreqScannerSettings.h"
 #include "SWGFreqTrackerReport.h"
 #include "SWGFreqTrackerSettings.h"
 #include "SWGFrequency.h"
@@ -1055,6 +1057,16 @@ namespace SWGSDRangel {
       obj->init();
       return obj;
     }
+    if(QString("SWGFreqScannerReport").compare(type) == 0) {
+      SWGFreqScannerReport *obj = new SWGFreqScannerReport();
+      obj->init();
+      return obj;
+    }
+    if(QString("SWGFreqScannerSettings").compare(type) == 0) {
+      SWGFreqScannerSettings *obj = new SWGFreqScannerSettings();
+      obj->init();
+      return obj;
+    }
     if(QString("SWGFreqTrackerReport").compare(type) == 0) {
       SWGFreqTrackerReport *obj = new SWGFreqTrackerReport();
       obj->init();

From 7fe7f2aa868ac19973cbf3cdcf24123b34b530bb Mon Sep 17 00:00:00 2001
From: srcejon <jon@beniston.com>
Date: Fri, 29 Sep 2023 08:42:25 +0100
Subject: [PATCH 04/23] Update threading to latest approach

---
 plugins/channelrx/freqscanner/freqscanner.cpp | 108 ++++++++++++------
 plugins/channelrx/freqscanner/freqscanner.h   |   3 +-
 .../freqscanner/freqscanneraddrangedialog.cpp |   6 +-
 .../freqscanner/freqscanneraddrangedialog.h   |   2 +-
 .../freqscanner/freqscannerbaseband.cpp       |  55 ++++-----
 .../freqscanner/freqscannerbaseband.h         |   6 +-
 .../channelrx/freqscanner/freqscannergui.cpp  |   4 +-
 7 files changed, 105 insertions(+), 79 deletions(-)

diff --git a/plugins/channelrx/freqscanner/freqscanner.cpp b/plugins/channelrx/freqscanner/freqscanner.cpp
index 38b36a106..42c00a2b6 100644
--- a/plugins/channelrx/freqscanner/freqscanner.cpp
+++ b/plugins/channelrx/freqscanner/freqscanner.cpp
@@ -63,6 +63,8 @@ const char * const FreqScanner::m_channelId = "FreqScanner";
 FreqScanner::FreqScanner(DeviceAPI *deviceAPI) :
         ChannelAPI(m_channelIdURI, ChannelAPI::StreamSingleSink),
         m_deviceAPI(deviceAPI),
+        m_thread(nullptr),
+        m_basebandSink(nullptr),
         m_running(false),
         m_basebandSampleRate(0),
         m_scanDeviceSetIndex(-1),
@@ -72,11 +74,6 @@ FreqScanner::FreqScanner(DeviceAPI *deviceAPI) :
 {
     setObjectName(m_channelId);
 
-    m_basebandSink = new FreqScannerBaseband(this);
-    m_basebandSink->setMessageQueueToChannel(getInputMessageQueue());
-    m_basebandSink->setChannel(this);
-    m_basebandSink->moveToThread(&m_thread);
-
     applySettings(m_settings, QStringList(), true);
 
     m_deviceAPI->addChannelSink(this);
@@ -96,6 +93,8 @@ FreqScanner::FreqScanner(DeviceAPI *deviceAPI) :
         &FreqScanner::handleIndexInDeviceSetChanged
     );
 
+    start();
+
     scanAvailableChannels();
     QObject::connect(
         MainCore::instance(),
@@ -126,11 +125,7 @@ FreqScanner::~FreqScanner()
     m_deviceAPI->removeChannelSinkAPI(this);
     m_deviceAPI->removeChannelSink(this);
 
-    if (m_basebandSink->isRunning()) {
-        stop();
-    }
-
-    delete m_basebandSink;
+    stop();
 }
 
 void FreqScanner::setDeviceAPI(DeviceAPI *deviceAPI)
@@ -161,16 +156,38 @@ void FreqScanner::feed(const SampleVector::const_iterator& begin, const SampleVe
 
 void FreqScanner::start()
 {
+    QMutexLocker m_lock(&m_mutex);
+
     if (m_running) {
         return;
     }
 
     qDebug("FreqScanner::start");
+    m_thread = new QThread();
+    m_basebandSink = new FreqScannerBaseband(this);
+    m_basebandSink->setFifoLabel(QString("%1 [%2:%3]")
+        .arg(m_channelId)
+        .arg(m_deviceAPI->getDeviceSetIndex())
+        .arg(getIndexInDeviceSet())
+    );
+    m_basebandSink->setMessageQueueToChannel(getInputMessageQueue());
+    m_basebandSink->setChannel(this);
+    m_basebandSink->moveToThread(m_thread);
 
-    m_basebandSink->reset();
-    m_basebandSink->startWork();
-    m_thread.start();
-    // FIXME: Threading!! Compare to SSB
+    QObject::connect(
+        m_thread,
+        &QThread::finished,
+        m_basebandSink,
+        &QObject::deleteLater
+    );
+    QObject::connect(
+        m_thread,
+        &QThread::finished,
+        m_thread,
+        &QThread::deleteLater
+    );
+
+    m_thread->start();
 
     DSPSignalNotification *dspMsg = new DSPSignalNotification(m_basebandSampleRate, m_centerFrequency);
     m_basebandSink->getInputMessageQueue()->push(dspMsg);
@@ -183,15 +200,16 @@ void FreqScanner::start()
 
 void FreqScanner::stop()
 {
+    QMutexLocker m_lock(&m_mutex);
+
     if (!m_running) {
         return;
     }
 
     qDebug("FreqScanner::stop");
     m_running = false;
-    m_basebandSink->stopWork();
-    m_thread.quit();
-    m_thread.wait();
+    m_thread->exit();
+    m_thread->wait();
 }
 
 bool FreqScanner::handleMessage(const Message& cmd)
@@ -314,17 +332,20 @@ void FreqScanner::processScanResults(const QDateTime& fftStartTime, const QList<
             }
             qSort(frequencies);
 
-            // Calculate how many channels can be scanned in one go
-            int fftSize;
-            int binsPerChannel;
-            FreqScanner::calcScannerSampleRate(m_settings.m_channelBandwidth, m_basebandSampleRate, m_scannerSampleRate, fftSize, binsPerChannel);
+            if ((frequencies.size() > 0) && (m_settings.m_channelBandwidth > 0) && (m_basebandSampleRate > 0))
+            {
+                // Calculate how many channels can be scanned in one go
+                int fftSize;
+                int binsPerChannel;
+                FreqScanner::calcScannerSampleRate(m_settings.m_channelBandwidth, m_basebandSampleRate, m_scannerSampleRate, fftSize, binsPerChannel);
 
-            // Align first frequency so we cover as many channels as possible, while avoiding DC bin
-            m_stepStartFrequency = frequencies.front() + m_scannerSampleRate / 2 - m_settings.m_channelBandwidth + m_settings.m_channelBandwidth / 2;
-            m_stepStopFrequency = frequencies.back();
+                // Align first frequency so we cover as many channels as possible, while avoiding DC bin
+                m_stepStartFrequency = frequencies.front() + m_scannerSampleRate / 2 - m_settings.m_channelBandwidth + m_settings.m_channelBandwidth / 2;
+                m_stepStopFrequency = frequencies.back();
 
-            qInfo() << "START_SCAN: Scanning from " << frequencies.front() << "to" << frequencies.back();
-            initScan();
+                qInfo() << "START_SCAN: Scanning from " << frequencies.front() << "to" << frequencies.back();
+                initScan();
+            }
         }
         break;
 
@@ -335,19 +356,36 @@ void FreqScanner::processScanResults(const QDateTime& fftStartTime, const QList<
                 m_scanResults.append(results);
             }
 
+            // Calculate next center frequency
             bool complete = false; // Have all frequencies been scanned?
+            bool freqInRange = false;
             qint64 nextCenterFrequency = m_centerFrequency;
+            do
+            {
+                if (nextCenterFrequency + m_scannerSampleRate / 2 > m_stepStopFrequency)
+                {
+                    nextCenterFrequency = m_stepStartFrequency;
+                    complete = true;
+                }
+                else
+                {
+                    nextCenterFrequency += m_scannerSampleRate;
+                    complete = false;
+                }
 
-            if (m_stepStopFrequency < m_centerFrequency + m_scannerSampleRate / 2)
-            {
-                nextCenterFrequency = m_stepStartFrequency;
-                complete = true;
-            }
-            else
-            {
-                nextCenterFrequency = m_centerFrequency + m_scannerSampleRate;
-                complete = false;
+                // Are any frequencies in this new range?
+                for (int i = 0; i < m_settings.m_frequencies.size(); i++)
+                {
+                    if (m_settings.m_enabled[i]
+                        && (m_settings.m_frequencies[i] >= nextCenterFrequency - m_scannerSampleRate / 2)
+                        && (m_settings.m_frequencies[i] < nextCenterFrequency + m_scannerSampleRate / 2))
+                    {
+                        freqInRange = true;
+                        break;
+                    }
+                }
             }
+            while (!complete && !freqInRange);
 
             if (complete)
             {
diff --git a/plugins/channelrx/freqscanner/freqscanner.h b/plugins/channelrx/freqscanner/freqscanner.h
index ff294b161..85a956a79 100644
--- a/plugins/channelrx/freqscanner/freqscanner.h
+++ b/plugins/channelrx/freqscanner/freqscanner.h
@@ -372,8 +372,9 @@ public:
 
 private:
     DeviceAPI *m_deviceAPI;
-    QThread m_thread;
+    QThread *m_thread;
     FreqScannerBaseband* m_basebandSink;
+    QRecursiveMutex m_mutex;
     bool m_running;
     FreqScannerSettings m_settings;
     int m_basebandSampleRate; //!< stored from device message used when starting baseband sink
diff --git a/plugins/channelrx/freqscanner/freqscanneraddrangedialog.cpp b/plugins/channelrx/freqscanner/freqscanneraddrangedialog.cpp
index afdd7e1e6..c08998641 100644
--- a/plugins/channelrx/freqscanner/freqscanneraddrangedialog.cpp
+++ b/plugins/channelrx/freqscanner/freqscanneraddrangedialog.cpp
@@ -18,7 +18,7 @@
 #include "freqscanneraddrangedialog.h"
 #include "ui_freqscanneraddrangedialog.h"
 
-FreqScannerAddRangeDialog::FreqScannerAddRangeDialog(QWidget* parent) :
+FreqScannerAddRangeDialog::FreqScannerAddRangeDialog(int step, QWidget* parent) :
     QDialog(parent),
     ui(new Ui::FreqScannerAddRangeDialog)
 {
@@ -32,6 +32,8 @@ FreqScannerAddRangeDialog::FreqScannerAddRangeDialog(QWidget* parent) :
     // Airband frequency range
     ui->start->setValue(118000000);
     ui->stop->setValue(137000000);
+
+    ui->step->setCurrentText(QString::number(step));
 }
 
 FreqScannerAddRangeDialog::~FreqScannerAddRangeDialog()
@@ -43,6 +45,6 @@ void FreqScannerAddRangeDialog::accept()
 {
     m_start = ui->start->getValue();
     m_stop = ui->stop->getValue();
-    m_step = ui->step->currentText().toLongLong();
+    m_step = ui->step->currentText().toInt();
     QDialog::accept();
 }
diff --git a/plugins/channelrx/freqscanner/freqscanneraddrangedialog.h b/plugins/channelrx/freqscanner/freqscanneraddrangedialog.h
index 8bacafe7f..7cb25b076 100644
--- a/plugins/channelrx/freqscanner/freqscanneraddrangedialog.h
+++ b/plugins/channelrx/freqscanner/freqscanneraddrangedialog.h
@@ -27,7 +27,7 @@ namespace Ui {
 class FreqScannerAddRangeDialog : public QDialog {
     Q_OBJECT
 public:
-    explicit FreqScannerAddRangeDialog(QWidget* parent = nullptr);
+    explicit FreqScannerAddRangeDialog(int step, QWidget* parent = nullptr);
     ~FreqScannerAddRangeDialog();
 
     qint64 m_start;
diff --git a/plugins/channelrx/freqscanner/freqscannerbaseband.cpp b/plugins/channelrx/freqscanner/freqscannerbaseband.cpp
index 1516505f1..8ad6fe125 100644
--- a/plugins/channelrx/freqscanner/freqscannerbaseband.cpp
+++ b/plugins/channelrx/freqscanner/freqscannerbaseband.cpp
@@ -29,15 +29,25 @@ MESSAGE_CLASS_DEFINITION(FreqScannerBaseband::MsgConfigureFreqScannerBaseband, M
 
 FreqScannerBaseband::FreqScannerBaseband(FreqScanner *freqScanner) :
     m_sink(freqScanner),
-    m_messageQueueToGUI(nullptr),
-    m_running(false)
+    m_messageQueueToGUI(nullptr)
 {
     qDebug("FreqScannerBaseband::FreqScannerBaseband");
 
     m_sampleFifo.setSize(SampleSinkFifo::getSizePolicy(48000));
+
+    QObject::connect(
+        &m_sampleFifo,
+        &SampleSinkFifo::dataReady,
+        this,
+        &FreqScannerBaseband::handleData,
+        Qt::QueuedConnection
+    );
+
     m_channelizer = new DownChannelizer(&m_sink);
     m_channelSampleRate = 0;
     m_scannerSampleRate = 0;
+
+    connect(&m_inputMessageQueue, SIGNAL(messageEnqueued()), this, SLOT(handleInputMessages()));
 }
 
 FreqScannerBaseband::~FreqScannerBaseband()
@@ -54,33 +64,6 @@ void FreqScannerBaseband::reset()
     m_channelSampleRate = 0;
 }
 
-void FreqScannerBaseband::startWork()
-{
-    QMutexLocker mutexLocker(&m_mutex);
-    QObject::connect(
-        &m_sampleFifo,
-        &SampleSinkFifo::dataReady,
-        this,
-        &FreqScannerBaseband::handleData,
-        Qt::QueuedConnection
-    );
-    connect(&m_inputMessageQueue, SIGNAL(messageEnqueued()), this, SLOT(handleInputMessages()));
-    m_running = true;
-}
-
-void FreqScannerBaseband::stopWork()
-{
-    QMutexLocker mutexLocker(&m_mutex);
-    disconnect(&m_inputMessageQueue, SIGNAL(messageEnqueued()), this, SLOT(handleInputMessages()));
-    QObject::disconnect(
-        &m_sampleFifo,
-        &SampleSinkFifo::dataReady,
-        this,
-        &FreqScannerBaseband::handleData
-    );
-    m_running = false;
-}
-
 void FreqScannerBaseband::setChannel(ChannelAPI *channel)
 {
     m_sink.setChannel(channel);
@@ -110,7 +93,7 @@ void FreqScannerBaseband::handleData()
         }
 
         // second part of FIFO data (used when block wraps around)
-        if(part2begin != part2end) {
+        if (part2begin != part2end) {
             m_channelizer->feed(part2begin, part2end);
         }
 
@@ -164,8 +147,12 @@ bool FreqScannerBaseband::handleMessage(const Message& cmd)
 
 void FreqScannerBaseband::applySettings(const FreqScannerSettings& settings, const QStringList& settingsKeys, bool force)
 {
-    if ((settings.m_channelBandwidth != m_settings.m_channelBandwidth) || (settings.m_inputFrequencyOffset != m_settings.m_inputFrequencyOffset) || force) {
-        calcScannerSampleRate(m_channelizer->getBasebandSampleRate(), settings.m_channelBandwidth, settings.m_inputFrequencyOffset);
+    if ((settings.m_channelBandwidth != m_settings.m_channelBandwidth) || (settings.m_inputFrequencyOffset != m_settings.m_inputFrequencyOffset) || force)
+    {
+        int basebandSampleRate = m_channelizer->getBasebandSampleRate();
+        if ((basebandSampleRate != 0) && (settings.m_channelBandwidth != 0)) {
+            calcScannerSampleRate(basebandSampleRate, settings.m_channelBandwidth, settings.m_inputFrequencyOffset);
+        }
     }
 
     m_sink.applySettings(settings, settingsKeys, force);
@@ -185,7 +172,9 @@ int FreqScannerBaseband::getChannelSampleRate() const
 void FreqScannerBaseband::setBasebandSampleRate(int sampleRate)
 {
     m_channelizer->setBasebandSampleRate(sampleRate);
-    calcScannerSampleRate(sampleRate, m_settings.m_channelBandwidth, m_settings.m_inputFrequencyOffset);
+    if ((sampleRate != 0) && (m_settings.m_channelBandwidth != 0)) {
+        calcScannerSampleRate(sampleRate, m_settings.m_channelBandwidth, m_settings.m_inputFrequencyOffset);
+    }
 }
 
 void FreqScannerBaseband::calcScannerSampleRate(int basebandSampleRate, float rfBandwidth, int inputFrequencyOffset)
diff --git a/plugins/channelrx/freqscanner/freqscannerbaseband.h b/plugins/channelrx/freqscanner/freqscannerbaseband.h
index 739a2cf8d..f638d7de9 100644
--- a/plugins/channelrx/freqscanner/freqscannerbaseband.h
+++ b/plugins/channelrx/freqscanner/freqscannerbaseband.h
@@ -62,11 +62,9 @@ public:
         { }
     };
 
-    FreqScannerBaseband(FreqScanner *packetDemod);
+    FreqScannerBaseband(FreqScanner *freqScanner);
     ~FreqScannerBaseband();
     void reset();
-    void startWork();
-    void stopWork();
     void feed(const SampleVector::const_iterator& begin, const SampleVector::const_iterator& end);
     MessageQueue *getInputMessageQueue() { return &m_inputMessageQueue; } //!< Get the queue for asynchronous inbound communication
     void setMessageQueueToChannel(MessageQueue *messageQueue) { m_sink.setMessageQueueToChannel(messageQueue); }
@@ -74,7 +72,6 @@ public:
     void setBasebandSampleRate(int sampleRate);
     int getChannelSampleRate() const;
     void setChannel(ChannelAPI *channel);
-    bool isRunning() const { return m_running; }
     void setFifoLabel(const QString& label) { m_sampleFifo.setLabel(label); }
 
 private:
@@ -86,7 +83,6 @@ private:
     MessageQueue m_inputMessageQueue; //!< Queue for asynchronous inbound communication
     MessageQueue *m_messageQueueToGUI;
     FreqScannerSettings m_settings;
-    bool m_running;
     QRecursiveMutex m_mutex;
 
     bool handleMessage(const Message& cmd);
diff --git a/plugins/channelrx/freqscanner/freqscannergui.cpp b/plugins/channelrx/freqscanner/freqscannergui.cpp
index 555bec411..71381c03c 100644
--- a/plugins/channelrx/freqscanner/freqscannergui.cpp
+++ b/plugins/channelrx/freqscanner/freqscannergui.cpp
@@ -411,7 +411,7 @@ FreqScannerGUI::FreqScannerGUI(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, B
     ui->deltaFrequency->setValueRange(true, 7, 0, 9999999);
 
     ui->channelBandwidth->setColorMapper(ColorMapper(ColorMapper::GrayGreenYellow));
-    ui->channelBandwidth->setValueRange(true, 7, 16, 9999999);
+    ui->channelBandwidth->setValueRange(true, 7, 0, 9999999);
 
     m_channelMarker.setColor(Qt::yellow);
     m_channelMarker.setCenterFrequency(m_settings.m_inputFrequencyOffset);
@@ -606,7 +606,7 @@ void FreqScannerGUI::on_addSingle_clicked()
 
 void FreqScannerGUI::on_addRange_clicked()
 {
-    FreqScannerAddRangeDialog dialog(this);
+    FreqScannerAddRangeDialog dialog(m_settings.m_channelBandwidth, this);
     new DialogPositioner(&dialog, false);
     if (dialog.exec())
     {

From f3582b95f5891c291ea5032e5ed4f395432e26ba Mon Sep 17 00:00:00 2001
From: srcejon <jon@beniston.com>
Date: Fri, 29 Sep 2023 08:42:47 +0100
Subject: [PATCH 05/23] Set background colour for start/stop button

---
 plugins/channelrx/noisefigure/noisefiguregui.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/plugins/channelrx/noisefigure/noisefiguregui.cpp b/plugins/channelrx/noisefigure/noisefiguregui.cpp
index 62161c1a4..9df17d599 100644
--- a/plugins/channelrx/noisefigure/noisefiguregui.cpp
+++ b/plugins/channelrx/noisefigure/noisefiguregui.cpp
@@ -667,6 +667,8 @@ NoiseFigureGUI::NoiseFigureGUI(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, B
     ui->results->setItemDelegateForColumn(RESULTS_COL_ENR, new DecimalDelegate(2));
     ui->results->setItemDelegateForColumn(RESULTS_COL_FLOOR, new DecimalDelegate(1));
 
+    ui->startStop->setStyleSheet(QString("QToolButton{ background-color: blue; } QToolButton:checked{ background-color: green; }"));
+
     displaySettings();
     makeUIConnections();
     applySettings(true);

From e9066fe2a44fa8155de807e3ed1ec69d9e69bd6a Mon Sep 17 00:00:00 2001
From: srcejon <jon@beniston.com>
Date: Fri, 29 Sep 2023 08:43:29 +0100
Subject: [PATCH 06/23] Use frame geo rather than widget size, so dialogs
 aren't positioned off screen on Windows.

---
 sdrgui/gui/dialogpositioner.cpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/sdrgui/gui/dialogpositioner.cpp b/sdrgui/gui/dialogpositioner.cpp
index 5482f30c0..7c9e4df30 100644
--- a/sdrgui/gui/dialogpositioner.cpp
+++ b/sdrgui/gui/dialogpositioner.cpp
@@ -79,18 +79,18 @@ void DialogPositioner::positionDialog(QWidget *dialog)
 
     // Position so fully on screen
     QRect desktop = dialog->screen()->availableGeometry();
-    QSize size = dialog->size();
+    QRect geometry = dialog->frameGeometry();
     QPoint pos = dialog->pos();
 
     bool move = false;
-    if (pos.x() + size.width() > desktop.width())
+    if (pos.x() + geometry.width() > desktop.width())
     {
-        pos.setX(desktop.width() - size.width());
+        pos.setX(desktop.width() - geometry.width());
         move = true;
     }
-    if (pos.y() + size.height() > desktop.height())
+    if (pos.y() + geometry.height() > desktop.height())
     {
-        pos.setY(desktop.height() - size.height());
+        pos.setY(desktop.height() - geometry.height());
         move = true;
     }
     if (move) {

From b3d3ca43ca61425e0958ebb0a5e352df0402a1bb Mon Sep 17 00:00:00 2001
From: srcejon <jon@beniston.com>
Date: Fri, 29 Sep 2023 09:38:15 +0100
Subject: [PATCH 07/23] Fix filtering of Freq Scanner from list of channels.

---
 plugins/channelrx/freqscanner/freqscanner.cpp    | 13 +++----------
 plugins/channelrx/freqscanner/freqscanner.h      |  1 -
 plugins/channelrx/freqscanner/freqscannergui.cpp |  4 ++--
 3 files changed, 5 insertions(+), 13 deletions(-)

diff --git a/plugins/channelrx/freqscanner/freqscanner.cpp b/plugins/channelrx/freqscanner/freqscanner.cpp
index 42c00a2b6..8c85f5587 100644
--- a/plugins/channelrx/freqscanner/freqscanner.cpp
+++ b/plugins/channelrx/freqscanner/freqscanner.cpp
@@ -243,16 +243,12 @@ bool FreqScanner::handleMessage(const Message& cmd)
     }
     else if (MsgStartScan::match(cmd))
     {
-        qInfo() << "FreqScanner::handleMessage: StartScan";
-
         startScan();
 
         return true;
     }
     else if (MsgStopScan::match(cmd))
     {
-        qInfo() << "FreqScanner::handleMessage: StopScan";
-
         stopScan();
 
         return true;
@@ -295,12 +291,10 @@ void FreqScanner::initScan()
 
     if (m_centerFrequency != m_stepStartFrequency)
     {
-        qInfo() << "******************** Setting frequency to " << m_stepStartFrequency;
         if (!ChannelWebAPIUtils::setCenterFrequency(getDeviceSetIndex(), m_stepStartFrequency)) {
-            qWarning() << "Scanner failed to set frequency" << m_stepStartFrequency;
+            qWarning() << "Freq Scanner failed to set frequency" << m_stepStartFrequency;
         }
         m_minFFTStartTime = QDateTime::currentDateTime().addMSecs(m_settings.m_tuneTime);
-        qInfo() << "m_minFFTStartTime" << m_minFFTStartTime.toString("ss.z");
     }
 
     m_scanResults.clear();
@@ -343,7 +337,6 @@ void FreqScanner::processScanResults(const QDateTime& fftStartTime, const QList<
                 m_stepStartFrequency = frequencies.front() + m_scannerSampleRate / 2 - m_settings.m_channelBandwidth + m_settings.m_channelBandwidth / 2;
                 m_stepStopFrequency = frequencies.back();
 
-                qInfo() << "START_SCAN: Scanning from " << frequencies.front() << "to" << frequencies.back();
                 initScan();
             }
         }
@@ -476,7 +469,7 @@ void FreqScanner::processScanResults(const QDateTime& fftStartTime, const QList<
                                 }
                             }
 
-                            //qInfo() << "Tuning to active freq:" << frequency << "m_centerFrequency" << m_centerFrequency << "nextCenterFrequency" << nextCenterFrequency << "offset: " << offset << "deviceset: R" << m_scanDeviceSetIndex << ":" << m_scanChannelIndex;
+                            //qDebug() << "Tuning to active freq:" << frequency << "m_centerFrequency" << m_centerFrequency << "nextCenterFrequency" << nextCenterFrequency << "offset: " << offset << "deviceset: R" << m_scanDeviceSetIndex << ":" << m_scanChannelIndex;
 
                             ChannelWebAPIUtils::setFrequencyOffset(m_scanDeviceSetIndex, m_scanChannelIndex, offset);
 
@@ -513,7 +506,7 @@ void FreqScanner::processScanResults(const QDateTime& fftStartTime, const QList<
             {
                 // For RTL SDR, setCenterFrequency takes ~50ms, which means tuneTime can be 0
                 if (!ChannelWebAPIUtils::setCenterFrequency(getDeviceSetIndex(), nextCenterFrequency)) {
-                    qWarning() << "Scanner failed to set frequency" << nextCenterFrequency;
+                    qWarning() << "Freq Scanner failed to set frequency" << nextCenterFrequency;
                 }
                 m_minFFTStartTime = QDateTime::currentDateTime().addMSecs(m_settings.m_tuneTime);
             }
diff --git a/plugins/channelrx/freqscanner/freqscanner.h b/plugins/channelrx/freqscanner/freqscanner.h
index 85a956a79..b4ab200f1 100644
--- a/plugins/channelrx/freqscanner/freqscanner.h
+++ b/plugins/channelrx/freqscanner/freqscanner.h
@@ -364,7 +364,6 @@ public:
         fftSize = pow(2.0, floor(log2(basebandSampleRate / binBW)));
         fftSize = std::min(maxFFTSize, fftSize);
         scannerSampleRate = binBW * fftSize;
-        qInfo() << "binsPerChannel:" << binsPerChannel << "fftSize:" << fftSize << "scannerSampleRate:" << scannerSampleRate;
     }
 
     static const char * const m_channelIdURI;
diff --git a/plugins/channelrx/freqscanner/freqscannergui.cpp b/plugins/channelrx/freqscanner/freqscannergui.cpp
index 71381c03c..81146f8cb 100644
--- a/plugins/channelrx/freqscanner/freqscannergui.cpp
+++ b/plugins/channelrx/freqscanner/freqscannergui.cpp
@@ -209,8 +209,8 @@ void FreqScannerGUI::updateChannelsList(const QList<FreqScannerSettings::Availab
 
     for (const auto& channel : channels)
     {
-        // Add channels in this device set, other than ourself
-        if ((channel.m_deviceSetIndex == getDeviceSetIndex()) && (channel.m_channelIndex != getIndex()))
+        // Add channels in this device set, other than ourself (Don't use ChannelGUI::getDeviceSetIndex()/getIndex() as not valid when this is first called)
+        if ((channel.m_deviceSetIndex == m_freqScanner->getDeviceSetIndex()) && (channel.m_channelIndex != m_freqScanner->getIndexInDeviceSet()))
         {
             QString name = QString("R%1:%2").arg(channel.m_deviceSetIndex).arg(channel.m_channelIndex);
             ui->channels->addItem(name);

From 3a8a0f0bf07094631a1adc2ab0f2d9d10af413cf Mon Sep 17 00:00:00 2001
From: srcejon <jon@beniston.com>
Date: Fri, 29 Sep 2023 10:52:21 +0100
Subject: [PATCH 08/23] Reduce debug. Add screenshot.

---
 doc/img/FreqScanner_plugin.png                  | Bin 0 -> 24596 bytes
 .../freqscanner/freqscannerbaseband.cpp         |   3 +--
 .../channelrx/freqscanner/freqscannergui.cpp    |   8 ++++++++
 .../freqscanner/freqscannersettings.cpp         |   8 +++++---
 4 files changed, 14 insertions(+), 5 deletions(-)
 create mode 100644 doc/img/FreqScanner_plugin.png

diff --git a/doc/img/FreqScanner_plugin.png b/doc/img/FreqScanner_plugin.png
new file mode 100644
index 0000000000000000000000000000000000000000..6bc7574e67e1e85a51b45157cdbf8615faaafcb5
GIT binary patch
literal 24596
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
I2(=3OFS#?uK>z>%

literal 0
HcmV?d00001

diff --git a/plugins/channelrx/freqscanner/freqscannerbaseband.cpp b/plugins/channelrx/freqscanner/freqscannerbaseband.cpp
index 8ad6fe125..d717ee3a8 100644
--- a/plugins/channelrx/freqscanner/freqscannerbaseband.cpp
+++ b/plugins/channelrx/freqscanner/freqscannerbaseband.cpp
@@ -187,8 +187,7 @@ void FreqScannerBaseband::calcScannerSampleRate(int basebandSampleRate, float rf
     m_channelizer->setChannelization(m_scannerSampleRate, inputFrequencyOffset);
     m_channelSampleRate = m_channelizer->getChannelSampleRate();
     m_sink.applyChannelSettings(m_channelSampleRate, m_channelizer->getChannelFrequencyOffset(), m_scannerSampleRate, fftSize, binsPerChannel);
-
-    qInfo() << "FreqScannerBaseband::calcScannerSampleRate"
+    qDebug() << "FreqScannerBaseband::calcScannerSampleRate"
         << "basebandSampleRate:" << basebandSampleRate
         << "channelSampleRate:" << m_channelSampleRate
         << "scannerSampleRate:" << m_scannerSampleRate
diff --git a/plugins/channelrx/freqscanner/freqscannergui.cpp b/plugins/channelrx/freqscanner/freqscannergui.cpp
index 81146f8cb..9e033df26 100644
--- a/plugins/channelrx/freqscanner/freqscannergui.cpp
+++ b/plugins/channelrx/freqscanner/freqscannergui.cpp
@@ -614,12 +614,20 @@ void FreqScannerGUI::on_addRange_clicked()
         qint64 stop = dialog.m_stop;
         int step = dialog.m_step;
 
+        blockApplySettings(true);
         if ((start <= stop) && (step > 0))
         {
             for (qint64 f = start; f <= stop; f += step) {
                 addRow(f, true);
             }
         }
+        blockApplySettings(false);
+        QList<QString> settingsKeys({
+            "frequencies",
+            "enabled",
+            "notes"
+        });
+        applySettings(settingsKeys);
     }
 }
 
diff --git a/plugins/channelrx/freqscanner/freqscannersettings.cpp b/plugins/channelrx/freqscanner/freqscannersettings.cpp
index d7ec2c6d9..8c6a00a15 100644
--- a/plugins/channelrx/freqscanner/freqscannersettings.cpp
+++ b/plugins/channelrx/freqscanner/freqscannersettings.cpp
@@ -295,14 +295,16 @@ QString FreqScannerSettings::getDebugString(const QStringList& settingsKeys, boo
     }
     if (settingsKeys.contains("enabled") || force)
     {
-        QStringList s;
+        // Don't display
+        /*QStringList s;
         for (auto e : m_enabled) {
             s.append(e ? "true" : "false");
         }
-        ostr << " m_enabled: " << s.join(",").toStdString();
+        ostr << " m_enabled: " << s.join(",").toStdString();*/
     }
     if (settingsKeys.contains("notes") || force) {
-        ostr << " m_notes: " << m_notes.join(",").toStdString();
+        // Don't display
+        //ostr << " m_notes: " << m_notes.join(",").toStdString();
     }
     if (settingsKeys.contains("channel") || force) {
         ostr << " m_channel: " << m_channel.toStdString();

From 4462078ead7bcd84f49ae24991ab4d585efe5a9c Mon Sep 17 00:00:00 2001
From: srcejon <jon@beniston.com>
Date: Fri, 29 Sep 2023 11:26:50 +0100
Subject: [PATCH 09/23] Update docs

---
 plugins/channelrx/freqscanner/readme.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/plugins/channelrx/freqscanner/readme.md b/plugins/channelrx/freqscanner/readme.md
index 1b3d1ab5f..9cef14bcd 100644
--- a/plugins/channelrx/freqscanner/readme.md
+++ b/plugins/channelrx/freqscanner/readme.md
@@ -34,12 +34,12 @@ that corresponds to the set frequency is being recieved.
 
 <h3>6: t_s - Scan time</h3>
 
-Specifies the time in seconds that the Frequency Scanner will average its channel power measurement over.
+Specifies the time in seconds that the Frequency Scanner will average its power measurement over.
 
 <h3>7: t_rtx - Retransmission Time</h3>
 
 Specifies the time in seconds that the Frequency Scanner will wait after the power on the active frequency falls below the threshold, before restarting
-scanning. This allows for a temporary break in transmission.
+scanning. This enables the channel to remain tuned to a single frequency while there is a temporary break in transmission.
 
 <h3>8: Ch BW - Channel Bandwidth</h3>
 
@@ -86,9 +86,9 @@ Displays the current status of the Frequency Scanner.
 The frequency table contains the list of frequencies to be scanned, along with results of a scan. The columns are:
 
 - Freq (Hz): Specifies the channel center frequencies to be scanned. These should be spaced by integer multiples of the channel bandwidth (8). Values should be entered in Hertz.
-- Annotation: An annotation (description) for the frequency, that is based on the closest matching [annotation marker](../../../sdrgui/gui/spectrummarkers.md) in the Main Spectrum.
+- Annotation: An annotation (description) for the frequency, that is obtained from the closest matching [annotation marker](../../../sdrgui/gui/spectrummarkers.md) in the Main Spectrum.
 - Enable: Determines whether the frequency will be scanned. This can be used to temporaily disable frequencies you aren't interested in.
-- Power (dB): Displays the measured power in decibels during the previous scan. The cell will have a green background if the power was above the threshold (4).
+- Power (dB): Displays the measured power in decibels from the last scan. The cell will have a green background if the power was above the threshold (4).
 - Active Count: Displays the number of scans in which the power for this frequency was above the threshold (4). This allows you to see which frequencies are commonly in use.
 - Notes: Available for user-entry of notes/information about this frequency.
 

From 33629b77e281424617d42affb536559c96321fba Mon Sep 17 00:00:00 2001
From: srcejon <jon@beniston.com>
Date: Fri, 29 Sep 2023 14:35:52 +0100
Subject: [PATCH 10/23] Center channels when possible. Fix channel setting
 initial display. Add clear active count button.

---
 plugins/channelrx/freqscanner/freqscanner.cpp | 10 ++++++++++
 .../channelrx/freqscanner/freqscannergui.cpp  | 19 +++++++++++++++++++
 .../channelrx/freqscanner/freqscannergui.h    |  1 +
 .../channelrx/freqscanner/freqscannergui.ui   | 14 ++++++++++++++
 plugins/channelrx/freqscanner/readme.md       |  8 +++++++-
 5 files changed, 51 insertions(+), 1 deletion(-)

diff --git a/plugins/channelrx/freqscanner/freqscanner.cpp b/plugins/channelrx/freqscanner/freqscanner.cpp
index 8c85f5587..0858dcbe0 100644
--- a/plugins/channelrx/freqscanner/freqscanner.cpp
+++ b/plugins/channelrx/freqscanner/freqscanner.cpp
@@ -337,6 +337,16 @@ void FreqScanner::processScanResults(const QDateTime& fftStartTime, const QList<
                 m_stepStartFrequency = frequencies.front() + m_scannerSampleRate / 2 - m_settings.m_channelBandwidth + m_settings.m_channelBandwidth / 2;
                 m_stepStopFrequency = frequencies.back();
 
+                // If all frequencies fit within bandwidth, we can have the first frequency more central
+                int totalBW = frequencies.back() - frequencies.front() + 2 * m_settings.m_channelBandwidth;
+                if (totalBW < m_scannerSampleRate)
+                {
+                    int spareBWEachSide = (m_scannerSampleRate - totalBW) / 2;
+                    int spareChannelsEachSide = spareBWEachSide / m_settings.m_channelBandwidth;
+                    int offset = spareChannelsEachSide * m_settings.m_channelBandwidth;
+                    m_stepStartFrequency -= offset;
+                }
+
                 initScan();
             }
         }
diff --git a/plugins/channelrx/freqscanner/freqscannergui.cpp b/plugins/channelrx/freqscanner/freqscannergui.cpp
index 9e033df26..4fa3b914c 100644
--- a/plugins/channelrx/freqscanner/freqscannergui.cpp
+++ b/plugins/channelrx/freqscanner/freqscannergui.cpp
@@ -505,6 +505,10 @@ void FreqScannerGUI::displaySettings()
 
     blockApplySettings(true);
 
+    int channelIndex = ui->channels->findText(m_settings.m_channel);
+    if (channelIndex >= 0) {
+        ui->channels->setCurrentIndex(channelIndex);
+    }
     ui->deltaFrequency->setValue(m_settings.m_channelFrequencyOffset);
     ui->channelBandwidth->setValue(m_settings.m_channelBandwidth);
     ui->scanTime->setValue(m_settings.m_scanTime * 10.0);
@@ -641,7 +645,14 @@ void FreqScannerGUI::on_remove_clicked()
         ui->table->removeRow(row);
         m_settings.m_frequencies.removeAt(row); // table_cellChanged isn't called for removeRow
         m_settings.m_enabled.removeAt(row);
+        m_settings.m_notes.removeAt(row);
     }
+    QList<QString> settingsKeys({
+        "frequencies",
+        "enabled",
+        "notes"
+    });
+    applySettings(settingsKeys);
 }
 
 static QList<QTableWidgetItem*> takeRow(QTableWidget* table, int row)
@@ -695,6 +706,13 @@ void FreqScannerGUI::on_down_clicked()
     }
 }
 
+void FreqScannerGUI::on_clearActiveCount_clicked()
+{
+    for (int i = 0; i < ui->table->rowCount(); i++) {
+        ui->table->item(i, COL_ACTIVE_COUNT)->setData(Qt::DisplayRole, 0);
+    }
+}
+
 void FreqScannerGUI::on_table_cellChanged(int row, int column)
 {
     QTableWidgetItem* item = ui->table->item(row, column);
@@ -911,6 +929,7 @@ void FreqScannerGUI::makeUIConnections()
     QObject::connect(ui->remove, &QToolButton::clicked, this, &FreqScannerGUI::on_remove_clicked);
     QObject::connect(ui->up, &QToolButton::clicked, this, &FreqScannerGUI::on_up_clicked);
     QObject::connect(ui->down, &QToolButton::clicked, this, &FreqScannerGUI::on_down_clicked);
+    QObject::connect(ui->clearActiveCount, &QToolButton::clicked, this, &FreqScannerGUI::on_clearActiveCount_clicked);
 }
 
 void FreqScannerGUI::updateAbsoluteCenterFrequency()
diff --git a/plugins/channelrx/freqscanner/freqscannergui.h b/plugins/channelrx/freqscanner/freqscannergui.h
index ef95ee212..35be2e571 100644
--- a/plugins/channelrx/freqscanner/freqscannergui.h
+++ b/plugins/channelrx/freqscanner/freqscannergui.h
@@ -134,6 +134,7 @@ private slots:
     void on_remove_clicked();
     void on_up_clicked();
     void on_down_clicked();
+    void on_clearActiveCount_clicked();
     void onWidgetRolled(QWidget* widget, bool rollDown);
     void onMenuDialogCalled(const QPoint& p);
     void handleInputMessages();
diff --git a/plugins/channelrx/freqscanner/freqscannergui.ui b/plugins/channelrx/freqscanner/freqscannergui.ui
index d00ed10e7..cd887b094 100644
--- a/plugins/channelrx/freqscanner/freqscannergui.ui
+++ b/plugins/channelrx/freqscanner/freqscannergui.ui
@@ -740,6 +740,20 @@
           </property>
          </spacer>
         </item>
+        <item>
+         <widget class="QToolButton" name="clearActiveCount">
+          <property name="toolTip">
+           <string>Clear Active Count in all rows</string>
+          </property>
+          <property name="text">
+           <string/>
+          </property>
+          <property name="icon">
+           <iconset resource="../../../sdrgui/resources/res.qrc">
+            <normaloff>:/bin.png</normaloff>:/bin.png</iconset>
+          </property>
+         </widget>
+        </item>
        </layout>
       </item>
      </layout>
diff --git a/plugins/channelrx/freqscanner/readme.md b/plugins/channelrx/freqscanner/readme.md
index 9cef14bcd..a6a71263a 100644
--- a/plugins/channelrx/freqscanner/readme.md
+++ b/plugins/channelrx/freqscanner/readme.md
@@ -16,7 +16,9 @@ Specifies the channel (such as an AM, NFM or DSD Demod), by device set and chann
 
 <h3>2: Minimum frequency shift from center frequency of reception for channel</h3>
 
-Use the wheels of keyboard to adjust the minimim frequency shift in Hz from the center frequency of reception for the channel (1). Left click on a digit sets the cursor position at this digit. Right click on a digit sets all digits on the right to zero. This effectively floors value at the digit position. Wheels are moved with the mousewheel while pointing at the wheel or by selecting the wheel with the left mouse click and using the keyboard arrows. Pressing shift simultaneously moves digit by 5 and pressing control moves it by 2.
+Use the wheels of keyboard to adjust the minimim frequency shift in Hz from the center frequency of reception for the channel (1).
+
+This setting is typically used to avoid having the channel (1) centered at DC, which can be problematic for some demodulators used with SDRs with a DC spike.
 
 <h3>3: Active frequency power</h3>
 
@@ -119,3 +121,7 @@ Moves the selected rows up the frequency table (14).
 <h3>19: Down</h3>
 
 Moves the selected rows the the frequency table (14).
+
+<h3>20: Clear Active Count</h3>
+
+Press to reset the value in the Active Count column to 0 for all rows.

From e89623f64d50565b68b63ba740dcd8e0ddae5d2b Mon Sep 17 00:00:00 2001
From: srcejon <jon@beniston.com>
Date: Fri, 29 Sep 2023 20:58:19 +0100
Subject: [PATCH 11/23] Fix restoring frequencies.

---
 plugins/channelrx/freqscanner/freqscanner.cpp    | 2 +-
 plugins/channelrx/freqscanner/freqscannergui.cpp | 2 ++
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/plugins/channelrx/freqscanner/freqscanner.cpp b/plugins/channelrx/freqscanner/freqscanner.cpp
index 0858dcbe0..ef0afc145 100644
--- a/plugins/channelrx/freqscanner/freqscanner.cpp
+++ b/plugins/channelrx/freqscanner/freqscanner.cpp
@@ -505,7 +505,7 @@ void FreqScanner::processScanResults(const QDateTime& fftStartTime, const QList<
                         else
                         {
                             if (m_guiMessageQueue) {
-                                m_guiMessageQueue->push(MsgStatus::create(QString("Scanning: No active channels - Max power %1 dB").arg(maxPower)));
+                                m_guiMessageQueue->push(MsgStatus::create(QString("Scanning: No active channels - Max power %1 dB").arg(maxPower, 0, 'f', 1)));
                             }
                         }
                     }
diff --git a/plugins/channelrx/freqscanner/freqscannergui.cpp b/plugins/channelrx/freqscanner/freqscannergui.cpp
index 4fa3b914c..66a2f3d62 100644
--- a/plugins/channelrx/freqscanner/freqscannergui.cpp
+++ b/plugins/channelrx/freqscanner/freqscannergui.cpp
@@ -523,9 +523,11 @@ void FreqScannerGUI::displaySettings()
     ui->measurement->setCurrentIndex((int)m_settings.m_measurement);
     ui->mode->setCurrentIndex((int)m_settings.m_mode);
 
+    ui->table->blockSignals(true);
     for (int i = 0; i < m_settings.m_frequencies.size(); i++) {
         addRow(m_settings.m_frequencies[i], m_settings.m_enabled[i], m_settings.m_notes[i]);
     }
+    ui->table->blockSignals(false);
 
     // Order and size columns
     QHeaderView* header = ui->table->horizontalHeader();

From f8f9d270dfb16de01489f061b91e72a4cb050d61 Mon Sep 17 00:00:00 2001
From: srcejon <jon@beniston.com>
Date: Fri, 29 Sep 2023 21:18:27 +0100
Subject: [PATCH 12/23] Update annotations when restoring settings.

---
 plugins/channelrx/freqscanner/freqscannergui.cpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/plugins/channelrx/freqscanner/freqscannergui.cpp b/plugins/channelrx/freqscanner/freqscannergui.cpp
index 66a2f3d62..9cd79d20e 100644
--- a/plugins/channelrx/freqscanner/freqscannergui.cpp
+++ b/plugins/channelrx/freqscanner/freqscannergui.cpp
@@ -524,8 +524,10 @@ void FreqScannerGUI::displaySettings()
     ui->mode->setCurrentIndex((int)m_settings.m_mode);
 
     ui->table->blockSignals(true);
-    for (int i = 0; i < m_settings.m_frequencies.size(); i++) {
+    for (int i = 0; i < m_settings.m_frequencies.size(); i++)
+    {
         addRow(m_settings.m_frequencies[i], m_settings.m_enabled[i], m_settings.m_notes[i]);
+        updateAnnotation(i);
     }
     ui->table->blockSignals(false);
 

From d2526cdc5bf7a6b687ce885ca877958916f9a268 Mon Sep 17 00:00:00 2001
From: srcejon <jon@beniston.com>
Date: Mon, 2 Oct 2023 15:45:17 +0100
Subject: [PATCH 13/23] Fix loading settings. Add remove inactive button.
 Restart scan when sample rate changes.

---
 plugins/channelrx/freqscanner/freqscanner.cpp |  10 +-
 .../freqscanner/freqscanneraddrangedialog.cpp |  88 +++++++-
 .../freqscanner/freqscanneraddrangedialog.h   |   5 +-
 .../freqscanner/freqscanneraddrangedialog.ui  | 190 +++++++++++-------
 .../channelrx/freqscanner/freqscannergui.cpp  |  45 ++++-
 .../channelrx/freqscanner/freqscannergui.h    |   1 +
 .../channelrx/freqscanner/freqscannergui.ui   |  20 +-
 plugins/channelrx/freqscanner/readme.md       |  15 +-
 8 files changed, 271 insertions(+), 103 deletions(-)

diff --git a/plugins/channelrx/freqscanner/freqscanner.cpp b/plugins/channelrx/freqscanner/freqscanner.cpp
index ef0afc145..14b00720a 100644
--- a/plugins/channelrx/freqscanner/freqscanner.cpp
+++ b/plugins/channelrx/freqscanner/freqscanner.cpp
@@ -225,7 +225,13 @@ bool FreqScanner::handleMessage(const Message& cmd)
     else if (DSPSignalNotification::match(cmd))
     {
         DSPSignalNotification& notif = (DSPSignalNotification&) cmd;
-        m_basebandSampleRate = notif.getSampleRate();
+        int newSampleRate = notif.getSampleRate();
+        if ((newSampleRate != m_basebandSampleRate) && (m_state != IDLE))
+        {
+            // Restart scan if sample rate changes
+            startScan();
+        }
+        m_basebandSampleRate = newSampleRate;
         m_centerFrequency = notif.getCenterFrequency();
         qDebug() << "FreqScanner::handleMessage: DSPSignalNotification";
         // Forward to the sink
@@ -645,7 +651,7 @@ void FreqScanner::applySettings(const FreqScannerSettings& settings, const QStri
     {
         // Restart scan if any settings change
         if (m_state != IDLE) {
-            m_state = START_SCAN;
+            startScan();
         }
     }
 
diff --git a/plugins/channelrx/freqscanner/freqscanneraddrangedialog.cpp b/plugins/channelrx/freqscanner/freqscanneraddrangedialog.cpp
index c08998641..cdf24d2cb 100644
--- a/plugins/channelrx/freqscanner/freqscanneraddrangedialog.cpp
+++ b/plugins/channelrx/freqscanner/freqscanneraddrangedialog.cpp
@@ -29,11 +29,9 @@ FreqScannerAddRangeDialog::FreqScannerAddRangeDialog(int step, QWidget* parent)
     ui->stop->setColorMapper(ColorMapper(ColorMapper::GrayGold));
     ui->stop->setValueRange(false, 11, 0, 99999999999);
 
-    // Airband frequency range
-    ui->start->setValue(118000000);
-    ui->stop->setValue(137000000);
+    on_preset_currentTextChanged("Airband");
 
-    ui->step->setCurrentText(QString::number(step));
+    //ui->step->setCurrentText(QString::number(step));
 }
 
 FreqScannerAddRangeDialog::~FreqScannerAddRangeDialog()
@@ -43,8 +41,84 @@ FreqScannerAddRangeDialog::~FreqScannerAddRangeDialog()
 
 void FreqScannerAddRangeDialog::accept()
 {
-    m_start = ui->start->getValue();
-    m_stop = ui->stop->getValue();
-    m_step = ui->step->currentText().toInt();
+    if (ui->preset->currentText() == "Digital Selective Calling")
+    {
+        // From ITU M.541
+        static const QList<qint64> dscFreqs = {
+            2177000, 2189500,
+            4208000, 4208500, 4209000,
+            6312500, 6313000,
+            8415000, 8415500, 8416000,
+            12577500, 12578000, 12578500,
+            16805000, 16805500, 16806000, 18898500, 18899000, 18899500,
+            22374500, 22375000, 22375500,
+            25208500, 25209000, 25209500
+        };
+        m_frequencies.append(dscFreqs);
+    }
+    else if (ui->preset->currentText() == "DAB")
+    {
+        static const QList<qint64> dabFreqs = {
+            174928000, 176640000, 178352000, 180064000,
+            181936000, 183648000, 185360000, 187072000,
+            188928000, 190640000, 192352000, 194064000,
+            195936000, 197648000, 199360000, 201072000,
+            202928000, 204640000, 206352000, 208064000,
+            209936000, 211648000, 213360000, 215072000,
+            216928000, 218640000, 220352000, 222064000,
+            223936000, 225648000, 227360000, 229072000,
+            230784000, 232496000, 234208000, 235776000,
+            237448000, 239200000
+        };
+        m_frequencies.append(dabFreqs);
+    }
+    else
+    {
+        qint64 start = ui->start->getValue();
+        qint64 stop = ui->stop->getValue();
+        int step = ui->step->currentText().toInt();
+
+        if ((start <= stop) && (step > 0))
+        {
+            for (qint64 f = start; f <= stop; f += step) {
+                m_frequencies.append(f);
+            }
+        }
+    }
+
     QDialog::accept();
 }
+
+void FreqScannerAddRangeDialog::on_preset_currentTextChanged(const QString& text)
+{
+    bool enableManAdjust = true;
+    if (text == "Airband")
+    {
+        ui->start->setValue(118000000);
+        ui->stop->setValue(137000000);
+        ui->step->setCurrentText("25000");
+    }
+    else if (text == "Broadcast FM")
+    {
+        ui->start->setValue(87500000);
+        ui->stop->setValue(108000000);
+        ui->step->setCurrentText("100000");
+    }
+    else if (text == "DAB")
+    {
+        enableManAdjust = false;
+    }
+    else if (text == "Marine")
+    {
+        ui->start->setValue(156000000);
+        ui->stop->setValue(162150000);
+        ui->step->setCurrentText("25000");
+    }
+    else if (text == "Digital Selective Calling")
+    {
+        enableManAdjust = false;
+    }
+    ui->start->setEnabled(enableManAdjust);
+    ui->stop->setEnabled(enableManAdjust);
+    ui->step->setEnabled(enableManAdjust);
+}
diff --git a/plugins/channelrx/freqscanner/freqscanneraddrangedialog.h b/plugins/channelrx/freqscanner/freqscanneraddrangedialog.h
index 7cb25b076..0a9f14e36 100644
--- a/plugins/channelrx/freqscanner/freqscanneraddrangedialog.h
+++ b/plugins/channelrx/freqscanner/freqscanneraddrangedialog.h
@@ -30,12 +30,11 @@ public:
     explicit FreqScannerAddRangeDialog(int step, QWidget* parent = nullptr);
     ~FreqScannerAddRangeDialog();
 
-    qint64 m_start;
-    qint64 m_stop;
-    int m_step;
+    QList<qint64> m_frequencies;
 
 private slots:
     void accept();
+    void on_preset_currentTextChanged(const QString& text);
 
 private:
     Ui::FreqScannerAddRangeDialog *ui;
diff --git a/plugins/channelrx/freqscanner/freqscanneraddrangedialog.ui b/plugins/channelrx/freqscanner/freqscanneraddrangedialog.ui
index 0cce5efe4..73cd0a1aa 100644
--- a/plugins/channelrx/freqscanner/freqscanneraddrangedialog.ui
+++ b/plugins/channelrx/freqscanner/freqscanneraddrangedialog.ui
@@ -7,7 +7,7 @@
     <x>0</x>
     <y>0</y>
     <width>385</width>
-    <height>162</height>
+    <height>190</height>
    </rect>
   </property>
   <property name="font">
@@ -31,82 +31,21 @@
       <string>Add Frequency Range</string>
      </property>
      <layout class="QGridLayout" name="gridLayout">
-      <item row="2" column="1">
-       <widget class="ValueDialZ" name="stop" native="true">
-        <property name="sizePolicy">
-         <sizepolicy hsizetype="Expanding" vsizetype="Maximum">
-          <horstretch>0</horstretch>
-          <verstretch>0</verstretch>
-         </sizepolicy>
-        </property>
-        <property name="minimumSize">
-         <size>
-          <width>32</width>
-          <height>16</height>
-         </size>
-        </property>
-        <property name="font">
-         <font>
-          <family>Liberation Mono</family>
-          <pointsize>12</pointsize>
-         </font>
-        </property>
-        <property name="cursor">
-         <cursorShape>PointingHandCursor</cursorShape>
-        </property>
-        <property name="focusPolicy">
-         <enum>Qt::StrongFocus</enum>
-        </property>
-        <property name="toolTip">
-         <string>Stop frequency in Hertz</string>
-        </property>
-       </widget>
-      </item>
-      <item row="2" column="0">
-       <widget class="QLabel" name="stopLabel">
+      <item row="4" column="0">
+       <widget class="QLabel" name="stepLabel">
         <property name="text">
-         <string>Stop Frequency</string>
+         <string>Step</string>
         </property>
        </widget>
       </item>
-      <item row="0" column="0">
-       <widget class="QLabel" name="startLabel">
-        <property name="minimumSize">
-         <size>
-          <width>90</width>
-          <height>0</height>
-         </size>
-        </property>
-        <property name="text">
-         <string>Start Frequency</string>
-        </property>
-       </widget>
-      </item>
-      <item row="2" column="2">
-       <widget class="QLabel" name="stopUnits">
+      <item row="1" column="2">
+       <widget class="QLabel" name="startUnits">
         <property name="text">
          <string>Hz</string>
         </property>
        </widget>
       </item>
-      <item row="3" column="1">
-       <widget class="QComboBox" name="step">
-        <property name="editable">
-         <bool>true</bool>
-        </property>
-        <item>
-         <property name="text">
-          <string>25000</string>
-         </property>
-        </item>
-        <item>
-         <property name="text">
-          <string>8333.3</string>
-         </property>
-        </item>
-       </widget>
-      </item>
-      <item row="0" column="1">
+      <item row="1" column="1">
        <widget class="ValueDialZ" name="start" native="true">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Expanding" vsizetype="Maximum">
@@ -137,24 +76,129 @@
         </property>
        </widget>
       </item>
-      <item row="3" column="2">
+      <item row="4" column="2">
        <widget class="QLabel" name="stepUnits">
         <property name="text">
          <string>Hz</string>
         </property>
        </widget>
       </item>
-      <item row="0" column="2">
-       <widget class="QLabel" name="startUnits">
+      <item row="3" column="2">
+       <widget class="QLabel" name="stopUnits">
         <property name="text">
          <string>Hz</string>
         </property>
        </widget>
       </item>
       <item row="3" column="0">
-       <widget class="QLabel" name="stepLabel">
+       <widget class="QLabel" name="stopLabel">
         <property name="text">
-         <string>Step</string>
+         <string>Stop Frequency</string>
+        </property>
+       </widget>
+      </item>
+      <item row="1" column="0">
+       <widget class="QLabel" name="startLabel">
+        <property name="minimumSize">
+         <size>
+          <width>90</width>
+          <height>0</height>
+         </size>
+        </property>
+        <property name="text">
+         <string>Start Frequency</string>
+        </property>
+       </widget>
+      </item>
+      <item row="4" column="1">
+       <widget class="QComboBox" name="step">
+        <property name="editable">
+         <bool>true</bool>
+        </property>
+        <item>
+         <property name="text">
+          <string>25000</string>
+         </property>
+        </item>
+        <item>
+         <property name="text">
+          <string>8333.3</string>
+         </property>
+        </item>
+        <item>
+         <property name="text">
+          <string>100000</string>
+         </property>
+        </item>
+       </widget>
+      </item>
+      <item row="3" column="1">
+       <widget class="ValueDialZ" name="stop" native="true">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Expanding" vsizetype="Maximum">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="minimumSize">
+         <size>
+          <width>32</width>
+          <height>16</height>
+         </size>
+        </property>
+        <property name="font">
+         <font>
+          <family>Liberation Mono</family>
+          <pointsize>12</pointsize>
+         </font>
+        </property>
+        <property name="cursor">
+         <cursorShape>PointingHandCursor</cursorShape>
+        </property>
+        <property name="focusPolicy">
+         <enum>Qt::StrongFocus</enum>
+        </property>
+        <property name="toolTip">
+         <string>Stop frequency in Hertz</string>
+        </property>
+       </widget>
+      </item>
+      <item row="0" column="1">
+       <widget class="QComboBox" name="preset">
+        <property name="toolTip">
+         <string>Select a preset range of frequencies</string>
+        </property>
+        <item>
+         <property name="text">
+          <string>Airband</string>
+         </property>
+        </item>
+        <item>
+         <property name="text">
+          <string>Broadcast FM</string>
+         </property>
+        </item>
+        <item>
+         <property name="text">
+          <string>DAB</string>
+         </property>
+        </item>
+        <item>
+         <property name="text">
+          <string>Digital Selective Calling</string>
+         </property>
+        </item>
+        <item>
+         <property name="text">
+          <string>Marine</string>
+         </property>
+        </item>
+       </widget>
+      </item>
+      <item row="0" column="0">
+       <widget class="QLabel" name="presetLabel">
+        <property name="text">
+         <string>Preset</string>
         </property>
        </widget>
       </item>
diff --git a/plugins/channelrx/freqscanner/freqscannergui.cpp b/plugins/channelrx/freqscanner/freqscannergui.cpp
index 9cd79d20e..520d4dbbc 100644
--- a/plugins/channelrx/freqscanner/freqscannergui.cpp
+++ b/plugins/channelrx/freqscanner/freqscannergui.cpp
@@ -504,7 +504,6 @@ void FreqScannerGUI::displaySettings()
     setTitle(m_channelMarker.getTitle());
 
     blockApplySettings(true);
-
     int channelIndex = ui->channels->findText(m_settings.m_channel);
     if (channelIndex >= 0) {
         ui->channels->setCurrentIndex(channelIndex);
@@ -524,6 +523,7 @@ void FreqScannerGUI::displaySettings()
     ui->mode->setCurrentIndex((int)m_settings.m_mode);
 
     ui->table->blockSignals(true);
+    ui->table->setRowCount(0);
     for (int i = 0; i < m_settings.m_frequencies.size(); i++)
     {
         addRow(m_settings.m_frequencies[i], m_settings.m_enabled[i], m_settings.m_notes[i]);
@@ -618,16 +618,9 @@ void FreqScannerGUI::on_addRange_clicked()
     new DialogPositioner(&dialog, false);
     if (dialog.exec())
     {
-        qint64 start = dialog.m_start;
-        qint64 stop = dialog.m_stop;
-        int step = dialog.m_step;
-
         blockApplySettings(true);
-        if ((start <= stop) && (step > 0))
-        {
-            for (qint64 f = start; f <= stop; f += step) {
-                addRow(f, true);
-            }
+        for (const auto f : dialog.m_frequencies) {
+            addRow(f, true);
         }
         blockApplySettings(false);
         QList<QString> settingsKeys({
@@ -659,6 +652,27 @@ void FreqScannerGUI::on_remove_clicked()
     applySettings(settingsKeys);
 }
 
+void FreqScannerGUI::on_removeInactive_clicked()
+{
+    for (int i = ui->table->rowCount() - 1; i >= 0; i--)
+    {
+        if (ui->table->item(i, COL_ACTIVE_COUNT)->data(Qt::DisplayRole).toInt() == 0)
+        {
+            ui->table->removeRow(i);
+            m_settings.m_frequencies.removeAt(i); // table_cellChanged isn't called for removeRow
+            m_settings.m_enabled.removeAt(i);
+            m_settings.m_notes.removeAt(i);
+        }
+    }
+    QList<QString> settingsKeys({
+        "frequencies",
+        "enabled",
+        "notes"
+        });
+    applySettings(settingsKeys);
+}
+
+
 static QList<QTableWidgetItem*> takeRow(QTableWidget* table, int row)
 {
     QList<QTableWidgetItem*> rowItems;
@@ -805,6 +819,14 @@ void FreqScannerGUI::table_customContextMenuRequested(QPoint pos)
             });
         tableContextMenu->addAction(copyAction);
 
+        // Remove selected rows
+
+        QAction* removeAction = new QAction("Remove", tableContextMenu);
+        connect(removeAction, &QAction::triggered, this, [this]()->void {
+            on_remove_clicked();
+            });
+        tableContextMenu->addAction(removeAction);
+
         tableContextMenu->addSeparator();
 
         // Tune to frequency
@@ -904,7 +926,7 @@ void FreqScannerGUI::resizeTable()
     // Fill table with a row of dummy data that will size the columns nicely
     int row = ui->table->rowCount();
     ui->table->setRowCount(row + 1);
-    ui->table->setItem(row, COL_FREQUENCY, new QTableWidgetItem("999.000 MHz"));
+    ui->table->setItem(row, COL_FREQUENCY, new QTableWidgetItem("800,000.5 MHz"));
     ui->table->setItem(row, COL_ANNOTATION, new QTableWidgetItem("An annotation"));
     ui->table->setItem(row, COL_ENABLE, new QTableWidgetItem("Enable"));
     ui->table->setItem(row, COL_POWER, new QTableWidgetItem("-100.0"));
@@ -931,6 +953,7 @@ void FreqScannerGUI::makeUIConnections()
     QObject::connect(ui->addSingle, &QToolButton::clicked, this, &FreqScannerGUI::on_addSingle_clicked);
     QObject::connect(ui->addRange, &QToolButton::clicked, this, &FreqScannerGUI::on_addRange_clicked);
     QObject::connect(ui->remove, &QToolButton::clicked, this, &FreqScannerGUI::on_remove_clicked);
+    QObject::connect(ui->removeInactive, &QToolButton::clicked, this, &FreqScannerGUI::on_removeInactive_clicked);
     QObject::connect(ui->up, &QToolButton::clicked, this, &FreqScannerGUI::on_up_clicked);
     QObject::connect(ui->down, &QToolButton::clicked, this, &FreqScannerGUI::on_down_clicked);
     QObject::connect(ui->clearActiveCount, &QToolButton::clicked, this, &FreqScannerGUI::on_clearActiveCount_clicked);
diff --git a/plugins/channelrx/freqscanner/freqscannergui.h b/plugins/channelrx/freqscanner/freqscannergui.h
index 35be2e571..9113fe514 100644
--- a/plugins/channelrx/freqscanner/freqscannergui.h
+++ b/plugins/channelrx/freqscanner/freqscannergui.h
@@ -132,6 +132,7 @@ private slots:
     void on_addSingle_clicked();
     void on_addRange_clicked();
     void on_remove_clicked();
+    void on_removeInactive_clicked();
     void on_up_clicked();
     void on_down_clicked();
     void on_clearActiveCount_clicked();
diff --git a/plugins/channelrx/freqscanner/freqscannergui.ui b/plugins/channelrx/freqscanner/freqscannergui.ui
index cd887b094..a22fa5160 100644
--- a/plugins/channelrx/freqscanner/freqscannergui.ui
+++ b/plugins/channelrx/freqscanner/freqscannergui.ui
@@ -181,6 +181,12 @@
        <layout class="QHBoxLayout" name="channelPowerLayout">
         <item>
          <widget class="QLabel" name="channelPower">
+          <property name="minimumSize">
+           <size>
+            <width>30</width>
+            <height>0</height>
+           </size>
+          </property>
           <property name="toolTip">
            <string>Active frequency power </string>
           </property>
@@ -231,10 +237,10 @@
          <string>Power threshold in dB</string>
         </property>
         <property name="minimum">
-         <number>-1400</number>
+         <number>-1000</number>
         </property>
         <property name="maximum">
-         <number>100</number>
+         <number>0</number>
         </property>
         <property name="pageStep">
          <number>1</number>
@@ -699,6 +705,16 @@
           </property>
          </widget>
         </item>
+        <item>
+         <widget class="QToolButton" name="removeInactive">
+          <property name="toolTip">
+           <string>Remove rows with Active Count of 0</string>
+          </property>
+          <property name="text">
+           <string>Remove Inactive</string>
+          </property>
+         </widget>
+        </item>
         <item>
          <widget class="QToolButton" name="up">
           <property name="toolTip">
diff --git a/plugins/channelrx/freqscanner/readme.md b/plugins/channelrx/freqscanner/readme.md
index a6a71263a..9f2de848f 100644
--- a/plugins/channelrx/freqscanner/readme.md
+++ b/plugins/channelrx/freqscanner/readme.md
@@ -87,7 +87,7 @@ Displays the current status of the Frequency Scanner.
 
 The frequency table contains the list of frequencies to be scanned, along with results of a scan. The columns are:
 
-- Freq (Hz): Specifies the channel center frequencies to be scanned. These should be spaced by integer multiples of the channel bandwidth (8). Values should be entered in Hertz.
+- Freq (Hz): Specifies the channel center frequencies to be scanned. Values should be entered in Hertz.
 - Annotation: An annotation (description) for the frequency, that is obtained from the closest matching [annotation marker](../../../sdrgui/gui/spectrummarkers.md) in the Main Spectrum.
 - Enable: Determines whether the frequency will be scanned. This can be used to temporaily disable frequencies you aren't interested in.
 - Power (dB): Displays the measured power in decibels from the last scan. The cell will have a green background if the power was above the threshold (4).
@@ -99,6 +99,7 @@ When an active frequency is found after a scan, the corresponding row in the tab
 Right clicking on a cell will display a popup menu:
 
 - Copy contents of cell to clipboard.
+- Remove selected rows.
 - Tune selected channel (1) to the frequency in the row clicked on.
 
 <h3>15: Add</h3>
@@ -112,16 +113,20 @@ The step value should typically be an integer multiple of the channel bandwidth
 
 <h3>17: Remove</h3>
 
-Removes the selected rows from the frequency table (14).
+Removes the selected rows from the frequency table (14). Press Ctrl-A to select all rows.
 
-<h3>18: Up</h3>
+<h3>18: Remove Inactive</h3>
+
+Removes all rows with Active Count of 0.
+
+<h3>19: Up</h3>
 
 Moves the selected rows up the frequency table (14).
 
-<h3>19: Down</h3>
+<h3>20: Down</h3>
 
 Moves the selected rows the the frequency table (14).
 
-<h3>20: Clear Active Count</h3>
+<h3>21: Clear Active Count</h3>
 
 Press to reset the value in the Active Count column to 0 for all rows.

From 83ceae4ba3155bec7dd3c5383add4b80eccf7870 Mon Sep 17 00:00:00 2001
From: srcejon <jon@beniston.com>
Date: Tue, 3 Oct 2023 16:09:54 +0100
Subject: [PATCH 14/23] Use full bandwidth

---
 plugins/channelrx/freqscanner/freqscanner.cpp | 32 ++++++++++++++++++-
 plugins/channelrx/freqscanner/freqscanner.h   | 18 +----------
 .../freqscanner/freqscannerbaseband.cpp       |  5 +--
 .../freqscanner/freqscannerbaseband.h         |  1 +
 .../channelrx/freqscanner/freqscannergui.cpp  | 24 +++++++++++---
 .../channelrx/freqscanner/freqscannergui.h    |  1 +
 .../channelrx/freqscanner/freqscannersink.cpp |  9 +++---
 plugins/channelrx/freqscanner/readme.md       |  4 ++-
 8 files changed, 64 insertions(+), 30 deletions(-)

diff --git a/plugins/channelrx/freqscanner/freqscanner.cpp b/plugins/channelrx/freqscanner/freqscanner.cpp
index 14b00720a..392faa30d 100644
--- a/plugins/channelrx/freqscanner/freqscanner.cpp
+++ b/plugins/channelrx/freqscanner/freqscanner.cpp
@@ -44,6 +44,7 @@
 #include "util/db.h"
 #include "channel/channelwebapiutils.h"
 #include "maincore.h"
+#include "dsp/spectrumvis.h"
 
 MESSAGE_CLASS_DEFINITION(FreqScanner::MsgConfigureFreqScanner, Message)
 MESSAGE_CLASS_DEFINITION(FreqScanner::MsgReportChannels, Message)
@@ -337,7 +338,7 @@ void FreqScanner::processScanResults(const QDateTime& fftStartTime, const QList<
                 // Calculate how many channels can be scanned in one go
                 int fftSize;
                 int binsPerChannel;
-                FreqScanner::calcScannerSampleRate(m_settings.m_channelBandwidth, m_basebandSampleRate, m_scannerSampleRate, fftSize, binsPerChannel);
+                calcScannerSampleRate(m_settings.m_channelBandwidth, m_basebandSampleRate, m_scannerSampleRate, fftSize, binsPerChannel);
 
                 // Align first frequency so we cover as many channels as possible, while avoiding DC bin
                 m_stepStartFrequency = frequencies.front() + m_scannerSampleRate / 2 - m_settings.m_channelBandwidth + m_settings.m_channelBandwidth / 2;
@@ -351,6 +352,8 @@ void FreqScanner::processScanResults(const QDateTime& fftStartTime, const QList<
                     int spareChannelsEachSide = spareBWEachSide / m_settings.m_channelBandwidth;
                     int offset = spareChannelsEachSide * m_settings.m_channelBandwidth;
                     m_stepStartFrequency -= offset;
+
+                    qDebug() << "*********** Starting scan: m_stepStartFrequency:" << m_stepStartFrequency << "offset:" << offset;
                 }
 
                 initScan();
@@ -582,6 +585,32 @@ void FreqScanner::timeout()
     initScan();
 }
 
+void FreqScanner::calcScannerSampleRate(int channelBW, int basebandSampleRate, int& scannerSampleRate, int& fftSize, int& binsPerChannel)
+{
+    const int maxFFTSize = 16384;
+    const int minBinsPerChannel = 8;
+
+    // Base FFT size on that used for main spectrum
+    std::vector<DeviceSet*>& deviceSets = MainCore::instance()->getDeviceSets();
+    DeviceSet* deviceSet = deviceSets[m_deviceAPI->getDeviceSetIndex()];
+    const SpectrumSettings& spectrumSettings = deviceSet->m_spectrumVis->getSettings();
+    fftSize = spectrumSettings.m_fftSize;
+
+    // But ensure we have several bins per channel
+    // Adjust sample rate, to ensure we don't get massive FFT size
+    scannerSampleRate = basebandSampleRate;
+    while (fftSize / (scannerSampleRate / channelBW) < minBinsPerChannel)
+    {
+        if (fftSize == maxFFTSize) {
+            scannerSampleRate /= 2;
+        } else {
+            fftSize *= 2;
+        }
+    }
+
+    binsPerChannel = fftSize / (scannerSampleRate / (float)channelBW);
+}
+
 void FreqScanner::setCenterFrequency(qint64 frequency)
 {
     FreqScannerSettings settings = m_settings;
@@ -647,6 +676,7 @@ void FreqScanner::applySettings(const FreqScannerSettings& settings, const QStri
         || settingsKeys.contains("priority")
         || settingsKeys.contains("measurement")
         || settingsKeys.contains("mode")
+        || settingsKeys.contains("channelBandwidth")
         || force)
     {
         // Restart scan if any settings change
diff --git a/plugins/channelrx/freqscanner/freqscanner.h b/plugins/channelrx/freqscanner/freqscanner.h
index b4ab200f1..80a53b79a 100644
--- a/plugins/channelrx/freqscanner/freqscanner.h
+++ b/plugins/channelrx/freqscanner/freqscanner.h
@@ -348,23 +348,7 @@ public:
 
     uint32_t getNumberOfDeviceStreams() const;
 
-    static void calcScannerSampleRate(int channelBW, int basebandSampleRate, int& scannerSampleRate, int& fftSize, int& binsPerChannel)
-    {
-        const int maxFFTSize = 2048;
-        const int maxBinsPerChannel = 32;
-        const int minBinsPerChannel = 8;
-
-        // Use multiple bins per channel, to account for FFT spectral leakage
-        binsPerChannel = maxFFTSize / (basebandSampleRate / channelBW);
-        binsPerChannel = std::min(binsPerChannel, maxBinsPerChannel);
-        binsPerChannel = std::max(binsPerChannel, minBinsPerChannel);
-        double binBW = channelBW / (double)binsPerChannel;
-
-        // Find next smallest power of 2
-        fftSize = pow(2.0, floor(log2(basebandSampleRate / binBW)));
-        fftSize = std::min(maxFFTSize, fftSize);
-        scannerSampleRate = binBW * fftSize;
-    }
+    void calcScannerSampleRate(int channelBW, int basebandSampleRate, int& scannerSampleRate, int& fftSize, int& binsPerChannel);
 
     static const char * const m_channelIdURI;
     static const char * const m_channelId;
diff --git a/plugins/channelrx/freqscanner/freqscannerbaseband.cpp b/plugins/channelrx/freqscanner/freqscannerbaseband.cpp
index d717ee3a8..189753c42 100644
--- a/plugins/channelrx/freqscanner/freqscannerbaseband.cpp
+++ b/plugins/channelrx/freqscanner/freqscannerbaseband.cpp
@@ -28,6 +28,7 @@
 MESSAGE_CLASS_DEFINITION(FreqScannerBaseband::MsgConfigureFreqScannerBaseband, Message)
 
 FreqScannerBaseband::FreqScannerBaseband(FreqScanner *freqScanner) :
+    m_freqScanner(freqScanner),
     m_sink(freqScanner),
     m_messageQueueToGUI(nullptr)
 {
@@ -147,7 +148,7 @@ bool FreqScannerBaseband::handleMessage(const Message& cmd)
 
 void FreqScannerBaseband::applySettings(const FreqScannerSettings& settings, const QStringList& settingsKeys, bool force)
 {
-    if ((settings.m_channelBandwidth != m_settings.m_channelBandwidth) || (settings.m_inputFrequencyOffset != m_settings.m_inputFrequencyOffset) || force)
+    if (settingsKeys.contains("channelBandwidth") || settingsKeys.contains("inputFrequencyOffset") || force)
     {
         int basebandSampleRate = m_channelizer->getBasebandSampleRate();
         if ((basebandSampleRate != 0) && (settings.m_channelBandwidth != 0)) {
@@ -182,7 +183,7 @@ void FreqScannerBaseband::calcScannerSampleRate(int basebandSampleRate, float rf
     int fftSize;
     int binsPerChannel;
 
-    FreqScanner::calcScannerSampleRate(rfBandwidth, basebandSampleRate, m_scannerSampleRate, fftSize, binsPerChannel);
+    m_freqScanner->calcScannerSampleRate(rfBandwidth, basebandSampleRate, m_scannerSampleRate, fftSize, binsPerChannel);
 
     m_channelizer->setChannelization(m_scannerSampleRate, inputFrequencyOffset);
     m_channelSampleRate = m_channelizer->getChannelSampleRate();
diff --git a/plugins/channelrx/freqscanner/freqscannerbaseband.h b/plugins/channelrx/freqscanner/freqscannerbaseband.h
index f638d7de9..bcd0ae6dc 100644
--- a/plugins/channelrx/freqscanner/freqscannerbaseband.h
+++ b/plugins/channelrx/freqscanner/freqscannerbaseband.h
@@ -75,6 +75,7 @@ public:
     void setFifoLabel(const QString& label) { m_sampleFifo.setLabel(label); }
 
 private:
+    FreqScanner *m_freqScanner;
     SampleSinkFifo m_sampleFifo;
     DownChannelizer *m_channelizer;
     int m_channelSampleRate;
diff --git a/plugins/channelrx/freqscanner/freqscannergui.cpp b/plugins/channelrx/freqscanner/freqscannergui.cpp
index 520d4dbbc..73c019430 100644
--- a/plugins/channelrx/freqscanner/freqscannergui.cpp
+++ b/plugins/channelrx/freqscanner/freqscannergui.cpp
@@ -103,7 +103,7 @@ bool FreqScannerGUI::handleMessage(const Message& message)
         m_basebandSampleRate = notif.getSampleRate();
         ui->deltaFrequency->setValueRange(true, 7, 0, m_basebandSampleRate/2);
         ui->deltaFrequencyLabel->setToolTip(tr("Range %1 %L2 Hz").arg(QChar(0xB1)).arg(m_basebandSampleRate/2));
-        ui->channelBandwidth->setValueRange(true, 7, 8, m_basebandSampleRate);
+        ui->channelBandwidth->setValueRange(true, 7, 0, m_basebandSampleRate);
         if (m_channelMarker.getBandwidth() == 0) {
             m_channelMarker.setBandwidth(m_basebandSampleRate);
         }
@@ -164,6 +164,7 @@ bool FreqScannerGUI::handleMessage(const Message& message)
         FreqScanner::MsgReportScanRange& report = (FreqScanner::MsgReportScanRange&)message;
         m_channelMarker.setCenterFrequency(report.getCenterFrequency());
         m_channelMarker.setBandwidth(report.getTotalBandwidth());
+        m_channelMarker.setVisible(report.getTotalBandwidth() < m_basebandSampleRate); // Hide marker if full bandwidth
         return true;
     }
     else if (FreqScanner::MsgScanResult::match(message))
@@ -417,7 +418,7 @@ FreqScannerGUI::FreqScannerGUI(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, B
     m_channelMarker.setCenterFrequency(m_settings.m_inputFrequencyOffset);
     m_channelMarker.setTitle("Frequency Scanner");
     m_channelMarker.blockSignals(false);
-    m_channelMarker.setVisible(true); // activate signal on the last setting only
+    m_channelMarker.setVisible(true);
 
     setTitleColor(m_channelMarker.getColor());
     m_settings.setChannelMarker(&m_channelMarker);
@@ -459,6 +460,8 @@ FreqScannerGUI::FreqScannerGUI(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, B
 
     ui->table->setItemDelegateForColumn(COL_FREQUENCY, new FrequencyDelegate("Auto", 3));
     ui->table->setItemDelegateForColumn(COL_POWER, new DecimalDelegate(1));
+
+    connect(m_deviceUISet->m_spectrum->getSpectrumView(), &GLSpectrumView::updateAnnotations, this, &FreqScannerGUI::updateAnnotations);
 }
 
 FreqScannerGUI::~FreqScannerGUI()
@@ -784,9 +787,13 @@ void FreqScannerGUI::updateAnnotation(int row)
                     // Exact match
                     annotationItem->setText(marker.m_text);
                     return;
-                } else if (!closest) {
+                }
+                else if (!closest)
+                {
                     closest = &marker;
-                } else {
+                }
+                else
+                {
                     if (marker.m_bandwidth < closest->m_bandwidth) {
                         closest = &marker;
                     }
@@ -799,6 +806,13 @@ void FreqScannerGUI::updateAnnotation(int row)
     }
 }
 
+void FreqScannerGUI::updateAnnotations()
+{
+    for (int i = 0; i < ui->table->rowCount(); i++) {
+        updateAnnotation(i);
+    }
+}
+
 void FreqScannerGUI::table_customContextMenuRequested(QPoint pos)
 {
     QTableWidgetItem* item = ui->table->itemAt(pos);
@@ -927,7 +941,7 @@ void FreqScannerGUI::resizeTable()
     int row = ui->table->rowCount();
     ui->table->setRowCount(row + 1);
     ui->table->setItem(row, COL_FREQUENCY, new QTableWidgetItem("800,000.5 MHz"));
-    ui->table->setItem(row, COL_ANNOTATION, new QTableWidgetItem("An annotation"));
+    ui->table->setItem(row, COL_ANNOTATION, new QTableWidgetItem("London VOLMET"));
     ui->table->setItem(row, COL_ENABLE, new QTableWidgetItem("Enable"));
     ui->table->setItem(row, COL_POWER, new QTableWidgetItem("-100.0"));
     ui->table->setItem(row, COL_ACTIVE_COUNT, new QTableWidgetItem("10000"));
diff --git a/plugins/channelrx/freqscanner/freqscannergui.h b/plugins/channelrx/freqscanner/freqscannergui.h
index 9113fe514..34979d1bf 100644
--- a/plugins/channelrx/freqscanner/freqscannergui.h
+++ b/plugins/channelrx/freqscanner/freqscannergui.h
@@ -94,6 +94,7 @@ private:
     void updateAbsoluteCenterFrequency();
     void addRow(qint64 frequency, bool enabled, const QString& notes = "");
     void updateAnnotation(int row);
+    void updateAnnotations();
     void updateChannelsList(const QList<FreqScannerSettings::AvailableChannel>& channels);
 
     void leaveEvent(QEvent*);
diff --git a/plugins/channelrx/freqscanner/freqscannersink.cpp b/plugins/channelrx/freqscanner/freqscannersink.cpp
index 01d8ed203..b4d9689dc 100644
--- a/plugins/channelrx/freqscanner/freqscannersink.cpp
+++ b/plugins/channelrx/freqscanner/freqscannersink.cpp
@@ -107,7 +107,7 @@ void FreqScannerSink::processOneSample(Complex &ci)
         if (m_fftAverage.nextAverage())
         {
             // Send results to channel
-            if (getMessageQueueToChannel())
+            if (getMessageQueueToChannel() && (m_settings.m_channelBandwidth != 0) && (m_binsPerChannel != 0))
             {
                 FreqScanner::MsgScanResult* msg = FreqScanner::MsgScanResult::create(m_fftStartTime);
                 QList<FreqScanner::MsgScanResult::ScanResult>& results = msg->getScanResults();
@@ -119,11 +119,11 @@ void FreqScannerSink::processOneSample(Complex &ci)
                         qint64 frequency = m_settings.m_frequencies[i];
                         qint64 startFrequency = m_centerFrequency - m_scannerSampleRate / 2;
                         qint64 diff = frequency - startFrequency;
-                        int binBW = m_settings.m_channelBandwidth / m_binsPerChannel;
+                        float binBW = m_scannerSampleRate / (float)m_fftSize;
 
                         if ((diff < m_scannerSampleRate) && (diff >= 0))
                         {
-                            int bin = diff / binBW;
+                            int bin = std::round(diff / binBW);
 
                             // Calculate power at that frequency
                             Real power;
@@ -132,7 +132,7 @@ void FreqScannerSink::processOneSample(Complex &ci)
                             } else {
                                 power = totalPower(bin);
                             }
-
+                            //qDebug() << "startFrequency:" << startFrequency << "m_scannerSampleRate:" << m_scannerSampleRate << "m_centerFrequency:" << m_centerFrequency << "frequency" << frequency << "bin" << bin << "power" << power;
                             FreqScanner::MsgScanResult::ScanResult result = {frequency, power};
                             results.append(result);
                         }
@@ -177,6 +177,7 @@ Real FreqScannerSink::peakPower(int bin) const
         if ((idx < 0) || (idx >= m_fftSize)) {
             continue;
         }
+        //qDebug() << "idx:" << idx << "power:" << CalcDb::dbPower(m_magSq[idx]);
         maxMagSq = std::max(maxMagSq, m_magSq[idx]);
     }
     Real db = CalcDb::dbPower(maxMagSq);
diff --git a/plugins/channelrx/freqscanner/readme.md b/plugins/channelrx/freqscanner/readme.md
index 9f2de848f..737c8325b 100644
--- a/plugins/channelrx/freqscanner/readme.md
+++ b/plugins/channelrx/freqscanner/readme.md
@@ -56,7 +56,9 @@ Specifies which frequency will be chosen as the active frequency, when multiple
 
 <h3>10: Meas - Power Measurement</h3>
 
-Specifies how power is measured. In both cases, a FFT is used, with the channel bandwidth being spread over 8 to 32 bins, with the first and last bins being excluded from the measurement (to reduce spectral leakage from adjacent channels):
+Specifies how power is measured. In both cases, a FFT is used.
+FFT size is typically the same as used for the Main Spectrum, but may be increased to ensure at least 8 bins cover the channel bandwidth (8).
+The first and last bins are excluded from the measurement (to reduce spectral leakage from adjacent channels):
 
 - Peak: Power is the highest value in all of the bins, averaged over the scan time (6).
 - Total: Power is the sum of power in all of the bins, averaged over the scan time (6).

From 2d8ae1329bcb2464e8b0344d1540b2a138e98ed9 Mon Sep 17 00:00:00 2001
From: srcejon <jon@beniston.com>
Date: Tue, 3 Oct 2023 16:10:08 +0100
Subject: [PATCH 15/23] Add signal for when annotations change

---
 sdrgui/gui/glspectrumview.cpp | 2 ++
 sdrgui/gui/glspectrumview.h   | 3 +++
 2 files changed, 5 insertions(+)

diff --git a/sdrgui/gui/glspectrumview.cpp b/sdrgui/gui/glspectrumview.cpp
index c5c47c0b2..9e3fb7ae5 100644
--- a/sdrgui/gui/glspectrumview.cpp
+++ b/sdrgui/gui/glspectrumview.cpp
@@ -3599,6 +3599,8 @@ void GLSpectrumView::updateWaterfallMarkers()
 
 void GLSpectrumView::updateAnnotationMarkers()
 {
+    emit updateAnnotations(); // Notify other plugins we have updated annotations
+
     if (!(m_markersDisplay & SpectrumSettings::MarkersDisplayAnnotations)) {
         return;
     }
diff --git a/sdrgui/gui/glspectrumview.h b/sdrgui/gui/glspectrumview.h
index 2d8a85c9a..40a080dbf 100644
--- a/sdrgui/gui/glspectrumview.h
+++ b/sdrgui/gui/glspectrumview.h
@@ -535,6 +535,9 @@ private slots:
 signals:
     // Emitted when user tries to scroll to frequency currently out of range
     void requestCenterFrequency(qint64 frequency);
+    // Emitted when annotations are changed
+    void updateAnnotations();
+
 };
 
 #endif // INCLUDE_GLSPECTRUMVIEW_H

From bb2655cd512e36ce8f41feca9b7fcc0ed1e0242f Mon Sep 17 00:00:00 2001
From: srcejon <jon@beniston.com>
Date: Tue, 3 Oct 2023 16:57:45 +0100
Subject: [PATCH 16/23] Fix warnings

---
 plugins/channelrx/freqscanner/freqscanner.cpp | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/plugins/channelrx/freqscanner/freqscanner.cpp b/plugins/channelrx/freqscanner/freqscanner.cpp
index 392faa30d..9e5aef364 100644
--- a/plugins/channelrx/freqscanner/freqscanner.cpp
+++ b/plugins/channelrx/freqscanner/freqscanner.cpp
@@ -331,7 +331,7 @@ void FreqScanner::processScanResults(const QDateTime& fftStartTime, const QList<
                     frequencies.append(m_settings.m_frequencies[i]);
                 }
             }
-            qSort(frequencies);
+            std::sort(frequencies.begin(), frequencies.end());
 
             if ((frequencies.size() > 0) && (m_settings.m_channelBandwidth > 0) && (m_basebandSampleRate > 0))
             {
@@ -352,8 +352,6 @@ void FreqScanner::processScanResults(const QDateTime& fftStartTime, const QList<
                     int spareChannelsEachSide = spareBWEachSide / m_settings.m_channelBandwidth;
                     int offset = spareChannelsEachSide * m_settings.m_channelBandwidth;
                     m_stepStartFrequency -= offset;
-
-                    qDebug() << "*********** Starting scan: m_stepStartFrequency:" << m_stepStartFrequency << "offset:" << offset;
                 }
 
                 initScan();

From 51ddd77aa3aa9c66827b63dc4c575a4ef2fa13a5 Mon Sep 17 00:00:00 2001
From: srcejon <jon@beniston.com>
Date: Fri, 13 Oct 2023 08:54:11 +0100
Subject: [PATCH 17/23] Fix 8333 channels.

---
 .../freqscanner/freqscanneraddrangedialog.cpp    | 16 ++++++++++++++--
 .../freqscanner/freqscanneraddrangedialog.ui     |  2 +-
 2 files changed, 15 insertions(+), 3 deletions(-)

diff --git a/plugins/channelrx/freqscanner/freqscanneraddrangedialog.cpp b/plugins/channelrx/freqscanner/freqscanneraddrangedialog.cpp
index cdf24d2cb..124322fa3 100644
--- a/plugins/channelrx/freqscanner/freqscanneraddrangedialog.cpp
+++ b/plugins/channelrx/freqscanner/freqscanneraddrangedialog.cpp
@@ -15,6 +15,8 @@
 // along with this program. If not, see <http://www.gnu.org/licenses/>.          //
 ///////////////////////////////////////////////////////////////////////////////////
 
+#include <cmath>
+
 #include "freqscanneraddrangedialog.h"
 #include "ui_freqscanneraddrangedialog.h"
 
@@ -80,8 +82,18 @@ void FreqScannerAddRangeDialog::accept()
 
         if ((start <= stop) && (step > 0))
         {
-            for (qint64 f = start; f <= stop; f += step) {
-                m_frequencies.append(f);
+            if (step == 8333)
+            {
+                double fstep = 8333 + 1.0/3.0; // float will give incorrect results
+                for (double f = start; f <= stop; f += fstep) {
+                    m_frequencies.append(std::round(f));
+                }
+            }
+            else
+            {
+                for (qint64 f = start; f <= stop; f += step) {
+                    m_frequencies.append(f);
+                }
             }
         }
     }
diff --git a/plugins/channelrx/freqscanner/freqscanneraddrangedialog.ui b/plugins/channelrx/freqscanner/freqscanneraddrangedialog.ui
index 73cd0a1aa..98cd619a9 100644
--- a/plugins/channelrx/freqscanner/freqscanneraddrangedialog.ui
+++ b/plugins/channelrx/freqscanner/freqscanneraddrangedialog.ui
@@ -122,7 +122,7 @@
         </item>
         <item>
          <property name="text">
-          <string>8333.3</string>
+          <string>8333</string>
          </property>
         </item>
         <item>

From 515e19f20b7a6628ddb47e7563b53d1002243278 Mon Sep 17 00:00:00 2001
From: srcejon <jon@beniston.com>
Date: Fri, 13 Oct 2023 08:54:43 +0100
Subject: [PATCH 18/23] Fix crash and tidy up UI.

---
 plugins/channelrx/freqscanner/freqscannergui.cpp  | 11 +++++++----
 plugins/channelrx/freqscanner/freqscannergui.ui   |  4 ++--
 plugins/channelrx/freqscanner/freqscannersink.cpp |  5 +++--
 3 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/plugins/channelrx/freqscanner/freqscannergui.cpp b/plugins/channelrx/freqscanner/freqscannergui.cpp
index 73c019430..d1931f8f6 100644
--- a/plugins/channelrx/freqscanner/freqscannergui.cpp
+++ b/plugins/channelrx/freqscanner/freqscannergui.cpp
@@ -101,9 +101,12 @@ bool FreqScannerGUI::handleMessage(const Message& message)
         DSPSignalNotification& notif = (DSPSignalNotification&) message;
         m_deviceCenterFrequency = notif.getCenterFrequency();
         m_basebandSampleRate = notif.getSampleRate();
-        ui->deltaFrequency->setValueRange(true, 7, 0, m_basebandSampleRate/2);
-        ui->deltaFrequencyLabel->setToolTip(tr("Range %1 %L2 Hz").arg(QChar(0xB1)).arg(m_basebandSampleRate/2));
-        ui->channelBandwidth->setValueRange(true, 7, 0, m_basebandSampleRate);
+        if (m_basebandSampleRate != 0)
+        {
+            ui->deltaFrequency->setValueRange(true, 7, 0, m_basebandSampleRate/2);
+            ui->deltaFrequencyLabel->setToolTip(tr("Range %1 %L2 Hz").arg(QChar(0xB1)).arg(m_basebandSampleRate/2));
+            ui->channelBandwidth->setValueRange(true, 7, 0, m_basebandSampleRate);
+        }
         if (m_channelMarker.getBandwidth() == 0) {
             m_channelMarker.setBandwidth(m_basebandSampleRate);
         }
@@ -363,7 +366,7 @@ void FreqScannerGUI::onMenuDialogCalled(const QPoint &p)
         setTitleColor(m_settings.m_rgbColor);
 
         QList<QString> settingsKeys({
-            "m_rgbColor",
+            "rgbColor",
             "title",
             "useReverseAPI",
             "reverseAPIAddress",
diff --git a/plugins/channelrx/freqscanner/freqscannergui.ui b/plugins/channelrx/freqscanner/freqscannergui.ui
index a22fa5160..7d6da12a2 100644
--- a/plugins/channelrx/freqscanner/freqscannergui.ui
+++ b/plugins/channelrx/freqscanner/freqscannergui.ui
@@ -313,12 +313,12 @@
        <widget class="QLabel" name="tuneTimeText">
         <property name="minimumSize">
          <size>
-          <width>45</width>
+          <width>54</width>
           <height>0</height>
          </size>
         </property>
         <property name="text">
-         <string>100 ms</string>
+         <string>1000 ms</string>
         </property>
        </widget>
       </item>
diff --git a/plugins/channelrx/freqscanner/freqscannersink.cpp b/plugins/channelrx/freqscanner/freqscannersink.cpp
index b4d9689dc..ab1408967 100644
--- a/plugins/channelrx/freqscanner/freqscannersink.cpp
+++ b/plugins/channelrx/freqscanner/freqscannersink.cpp
@@ -171,8 +171,9 @@ Real FreqScannerSink::peakPower(int bin) const
     // Skip bin between halfway between channels
     // Then skip first and last bins, to avoid spectral leakage (particularly at DC)
     int startBin = bin - m_binsPerChannel/2 + 1 + 1;
-    Real maxMagSq = m_magSq[startBin];
-    for (int i = 1; i < m_binsPerChannel - 2 - 1; i++) {
+    Real maxMagSq = std::numeric_limits<Real>::min();
+    for (int i = 0; i < m_binsPerChannel - 2 - 1; i++)
+    {
         int idx = startBin + i;
         if ((idx < 0) || (idx >= m_fftSize)) {
             continue;

From ce6b08b15ec904ed8a68cde6743254204ff5284c Mon Sep 17 00:00:00 2001
From: srcejon <jon@beniston.com>
Date: Sun, 22 Oct 2023 10:01:29 +0100
Subject: [PATCH 19/23] Add menu to enable/disable all rows.

---
 .../channelrx/freqscanner/freqscannergui.cpp  | 33 ++++++++++++++++++-
 .../channelrx/freqscanner/freqscannergui.h    |  1 +
 plugins/channelrx/freqscanner/readme.md       |  4 +++
 3 files changed, 37 insertions(+), 1 deletion(-)

diff --git a/plugins/channelrx/freqscanner/freqscannergui.cpp b/plugins/channelrx/freqscanner/freqscannergui.cpp
index d1931f8f6..0710c4757 100644
--- a/plugins/channelrx/freqscanner/freqscannergui.cpp
+++ b/plugins/channelrx/freqscanner/freqscannergui.cpp
@@ -784,7 +784,13 @@ void FreqScannerGUI::updateAnnotation(int row)
         const SpectrumAnnotationMarker* closest = nullptr;
         for (const auto& marker : markers)
         {
-            if ((marker.m_startFrequency <= frequency) && (frequency < marker.m_startFrequency + marker.m_bandwidth))
+            qint64 start1 = marker.m_startFrequency;
+            qint64 stop1 = marker.m_startFrequency + marker.m_bandwidth;
+            qint64 start2 = frequency - m_settings.m_channelBandwidth / 2;
+            qint64 stop2 = frequency + m_settings.m_channelBandwidth / 2;
+            if (   ((start2 >= start1) && (start2 <= stop1))
+                || ((stop2 >= start1) && (stop2 <= stop1))
+               )
             {
                 if (marker.m_bandwidth == (unsigned)m_settings.m_channelBandwidth) {
                     // Exact match
@@ -816,6 +822,13 @@ void FreqScannerGUI::updateAnnotations()
     }
 }
 
+void FreqScannerGUI::setAllEnabled(bool enable)
+{
+    for (int i = 0; i < ui->table->rowCount(); i++) {
+        ui->table->item(i, COL_ENABLE)->setCheckState(enable ? Qt::Checked : Qt::Unchecked);
+    }
+}
+
 void FreqScannerGUI::table_customContextMenuRequested(QPoint pos)
 {
     QTableWidgetItem* item = ui->table->itemAt(pos);
@@ -836,6 +849,24 @@ void FreqScannerGUI::table_customContextMenuRequested(QPoint pos)
             });
         tableContextMenu->addAction(copyAction);
 
+        tableContextMenu->addSeparator();
+
+        // Enable all
+
+        QAction* enableAllAction = new QAction("Enable all", tableContextMenu);
+        connect(enableAllAction, &QAction::triggered, this, [this]()->void {
+            setAllEnabled(true);
+            });
+        tableContextMenu->addAction(enableAllAction);
+
+        // Disable all
+
+        QAction* disableAllAction = new QAction("Disable all", tableContextMenu);
+        connect(disableAllAction, &QAction::triggered, this, [this]()->void {
+            setAllEnabled(false);
+            });
+        tableContextMenu->addAction(disableAllAction);
+
         // Remove selected rows
 
         QAction* removeAction = new QAction("Remove", tableContextMenu);
diff --git a/plugins/channelrx/freqscanner/freqscannergui.h b/plugins/channelrx/freqscanner/freqscannergui.h
index 34979d1bf..9e0ec56c0 100644
--- a/plugins/channelrx/freqscanner/freqscannergui.h
+++ b/plugins/channelrx/freqscanner/freqscannergui.h
@@ -96,6 +96,7 @@ private:
     void updateAnnotation(int row);
     void updateAnnotations();
     void updateChannelsList(const QList<FreqScannerSettings::AvailableChannel>& channels);
+    void setAllEnabled(bool enable);
 
     void leaveEvent(QEvent*);
     void enterEvent(EnterEventType*);
diff --git a/plugins/channelrx/freqscanner/readme.md b/plugins/channelrx/freqscanner/readme.md
index 737c8325b..d5126484f 100644
--- a/plugins/channelrx/freqscanner/readme.md
+++ b/plugins/channelrx/freqscanner/readme.md
@@ -4,6 +4,8 @@
 
 This plugin can be used to scan a range of frequencies looking for a transmission and then tune another channel (such as an AM or DSD Demod) to that frequency.
 
+[Tutorial Video](https://www.youtube.com/watch?v=IpKP3t4Bmmg)
+
 <h2>Interface</h2>
 
 The top and bottom bars of the channel window are described [here](../../../sdrgui/channel/readme.md)
@@ -101,6 +103,8 @@ When an active frequency is found after a scan, the corresponding row in the tab
 Right clicking on a cell will display a popup menu:
 
 - Copy contents of cell to clipboard.
+- Enable all rows.
+- Disable all rows.
 - Remove selected rows.
 - Tune selected channel (1) to the frequency in the row clicked on.
 

From 3e147ec804bbaa9d1884951dd9a3bfadf5596b77 Mon Sep 17 00:00:00 2001
From: srcejon <jon@beniston.com>
Date: Sun, 22 Oct 2023 10:03:04 +0100
Subject: [PATCH 20/23] Avoid using channel guard bands, due to possible
 aliasing from half-band filters

---
 plugins/channelrx/freqscanner/freqscanner.cpp | 46 ++++++++++---------
 plugins/channelrx/freqscanner/freqscanner.h   |  1 +
 .../channelrx/freqscanner/freqscannersink.cpp | 13 ++----
 3 files changed, 30 insertions(+), 30 deletions(-)

diff --git a/plugins/channelrx/freqscanner/freqscanner.cpp b/plugins/channelrx/freqscanner/freqscanner.cpp
index 9e5aef364..31a45e8ef 100644
--- a/plugins/channelrx/freqscanner/freqscanner.cpp
+++ b/plugins/channelrx/freqscanner/freqscanner.cpp
@@ -292,16 +292,21 @@ void FreqScanner::stopScan()
     }
 }
 
+void FreqScanner::setDeviceCenterFrequency(qint64 frequency)
+{
+    // For RTL SDR, ChannelWebAPIUtils::setCenterFrequency takes ~50ms, which means tuneTime can be 0
+    if (!ChannelWebAPIUtils::setCenterFrequency(getDeviceSetIndex(), frequency)) {
+        qWarning() << "Freq Scanner failed to set frequency" << frequency;
+    }
+    m_minFFTStartTime = QDateTime::currentDateTime().addMSecs(m_settings.m_tuneTime);
+}
+
 void FreqScanner::initScan()
 {
     ChannelWebAPIUtils::setAudioMute(m_scanDeviceSetIndex, m_scanChannelIndex, true);
 
-    if (m_centerFrequency != m_stepStartFrequency)
-    {
-        if (!ChannelWebAPIUtils::setCenterFrequency(getDeviceSetIndex(), m_stepStartFrequency)) {
-            qWarning() << "Freq Scanner failed to set frequency" << m_stepStartFrequency;
-        }
-        m_minFFTStartTime = QDateTime::currentDateTime().addMSecs(m_settings.m_tuneTime);
+    if (m_centerFrequency != m_stepStartFrequency) {
+        setDeviceCenterFrequency(m_stepStartFrequency);
     }
 
     m_scanResults.clear();
@@ -340,13 +345,14 @@ void FreqScanner::processScanResults(const QDateTime& fftStartTime, const QList<
                 int binsPerChannel;
                 calcScannerSampleRate(m_settings.m_channelBandwidth, m_basebandSampleRate, m_scannerSampleRate, fftSize, binsPerChannel);
 
-                // Align first frequency so we cover as many channels as possible, while avoiding DC bin
-                m_stepStartFrequency = frequencies.front() + m_scannerSampleRate / 2 - m_settings.m_channelBandwidth + m_settings.m_channelBandwidth / 2;
+                // Align first frequency so we cover as many channels as possible, while channel guard band
+                // Can we adjust this to avoid DC bin?
+                m_stepStartFrequency = frequencies.front() + m_scannerSampleRate / 2 - m_scannerSampleRate * 0.125f;
                 m_stepStopFrequency = frequencies.back();
 
-                // If all frequencies fit within bandwidth, we can have the first frequency more central
+                // If all frequencies fit within usable bandwidth, we can have the first frequency more central
                 int totalBW = frequencies.back() - frequencies.front() + 2 * m_settings.m_channelBandwidth;
-                if (totalBW < m_scannerSampleRate)
+                if (totalBW < m_scannerSampleRate * 0.75f)
                 {
                     int spareBWEachSide = (m_scannerSampleRate - totalBW) / 2;
                     int spareChannelsEachSide = spareBWEachSide / m_settings.m_channelBandwidth;
@@ -370,16 +376,17 @@ void FreqScanner::processScanResults(const QDateTime& fftStartTime, const QList<
             bool complete = false; // Have all frequencies been scanned?
             bool freqInRange = false;
             qint64 nextCenterFrequency = m_centerFrequency;
+            float usableBW = m_scannerSampleRate * 0.75f;
             do
             {
-                if (nextCenterFrequency + m_scannerSampleRate / 2 > m_stepStopFrequency)
+                if (nextCenterFrequency + usableBW / 2 > m_stepStopFrequency)
                 {
                     nextCenterFrequency = m_stepStartFrequency;
                     complete = true;
                 }
                 else
                 {
-                    nextCenterFrequency += m_scannerSampleRate;
+                    nextCenterFrequency += usableBW;
                     complete = false;
                 }
 
@@ -387,8 +394,8 @@ void FreqScanner::processScanResults(const QDateTime& fftStartTime, const QList<
                 for (int i = 0; i < m_settings.m_frequencies.size(); i++)
                 {
                     if (m_settings.m_enabled[i]
-                        && (m_settings.m_frequencies[i] >= nextCenterFrequency - m_scannerSampleRate / 2)
-                        && (m_settings.m_frequencies[i] < nextCenterFrequency + m_scannerSampleRate / 2))
+                        && (m_settings.m_frequencies[i] >= nextCenterFrequency - usableBW / 2)
+                        && (m_settings.m_frequencies[i] < nextCenterFrequency + usableBW / 2))
                     {
                         freqInRange = true;
                         break;
@@ -457,7 +464,7 @@ void FreqScanner::processScanResults(const QDateTime& fftStartTime, const QList<
 
                             // Tune device/channel to frequency
                             int offset;
-                            if ((frequency < m_centerFrequency - m_scannerSampleRate / 2) || (frequency >= m_centerFrequency + m_scannerSampleRate / 2))
+                            if ((frequency < m_centerFrequency - usableBW / 2) || (frequency >= m_centerFrequency + usableBW / 2))
                             {
                                 nextCenterFrequency = frequency;
                                 offset = 0;
@@ -519,13 +526,8 @@ void FreqScanner::processScanResults(const QDateTime& fftStartTime, const QList<
                 }
             }
 
-            if (nextCenterFrequency != m_centerFrequency)
-            {
-                // For RTL SDR, setCenterFrequency takes ~50ms, which means tuneTime can be 0
-                if (!ChannelWebAPIUtils::setCenterFrequency(getDeviceSetIndex(), nextCenterFrequency)) {
-                    qWarning() << "Freq Scanner failed to set frequency" << nextCenterFrequency;
-                }
-                m_minFFTStartTime = QDateTime::currentDateTime().addMSecs(m_settings.m_tuneTime);
+            if (nextCenterFrequency != m_centerFrequency) {
+                setDeviceCenterFrequency(nextCenterFrequency);
             }
 
             if (complete) {
diff --git a/plugins/channelrx/freqscanner/freqscanner.h b/plugins/channelrx/freqscanner/freqscanner.h
index 80a53b79a..cd65b1fcf 100644
--- a/plugins/channelrx/freqscanner/freqscanner.h
+++ b/plugins/channelrx/freqscanner/freqscanner.h
@@ -405,6 +405,7 @@ private:
     void stopScan();
     void initScan();
     void processScanResults(const QDateTime& fftStartTime, const QList<MsgScanResult::ScanResult>& results);
+    void setDeviceCenterFrequency(qint64 frequency);
 
 private slots:
     void networkManagerFinished(QNetworkReply *reply);
diff --git a/plugins/channelrx/freqscanner/freqscannersink.cpp b/plugins/channelrx/freqscanner/freqscannersink.cpp
index ab1408967..79488e0cc 100644
--- a/plugins/channelrx/freqscanner/freqscannersink.cpp
+++ b/plugins/channelrx/freqscanner/freqscannersink.cpp
@@ -58,11 +58,7 @@ void FreqScannerSink::feed(const SampleVector::const_iterator& begin, const Samp
         Complex c(it->real(), it->imag());
         c *= m_nco.nextIQ();
 
-        if (m_interpolatorDistance == 1.0f) // Don't call decimate, as we don't want filter applied if possible
-        {
-            processOneSample(c);
-        }
-        else if (m_interpolatorDistance < 1.0f) // interpolate
+        if (m_interpolatorDistance < 1.0f) // interpolate
         {
             while (!m_interpolator.interpolate(&m_interpolatorDistanceRemain, c, &ci))
             {
@@ -70,7 +66,7 @@ void FreqScannerSink::feed(const SampleVector::const_iterator& begin, const Samp
                 m_interpolatorDistanceRemain += m_interpolatorDistance;
             }
         }
-        else // decimate
+        else // decimate (and filter)
         {
             if (m_interpolator.decimate(&m_interpolatorDistanceRemain, c, &ci))
             {
@@ -121,7 +117,8 @@ void FreqScannerSink::processOneSample(Complex &ci)
                         qint64 diff = frequency - startFrequency;
                         float binBW = m_scannerSampleRate / (float)m_fftSize;
 
-                        if ((diff < m_scannerSampleRate) && (diff >= 0))
+                        // Ignore results in uppper and lower 12.5%, as there may be aliasing here from half-band filters
+                        if ((diff < m_scannerSampleRate * 0.875f) && (diff >= m_scannerSampleRate * 0.125f))
                         {
                             int bin = std::round(diff / binBW);
 
@@ -210,7 +207,7 @@ void FreqScannerSink::applyChannelSettings(int channelSampleRate, int channelFre
 
     if ((m_channelSampleRate != channelSampleRate) || (m_scannerSampleRate != scannerSampleRate) || force)
     {
-        m_interpolator.create(16, channelSampleRate, scannerSampleRate / 2.0); // Highest cutoff, so we don't attentuate first/last channel
+        m_interpolator.create(16, channelSampleRate, scannerSampleRate / 2.2); // Filter potential aliasing resulting from half-band filters
         m_interpolatorDistance = (Real) channelSampleRate / (Real)scannerSampleRate;
         m_interpolatorDistanceRemain = m_interpolatorDistance;
     }

From 1b392ee53ceb771449a338ba1c79542d570aec43 Mon Sep 17 00:00:00 2001
From: srcejon <jon@beniston.com>
Date: Sun, 22 Oct 2023 10:25:08 +0100
Subject: [PATCH 21/23] Fix warnings

---
 sdrgui/gui/frequencydelegate.cpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/sdrgui/gui/frequencydelegate.cpp b/sdrgui/gui/frequencydelegate.cpp
index cb4a2b470..d7ab73a0c 100644
--- a/sdrgui/gui/frequencydelegate.cpp
+++ b/sdrgui/gui/frequencydelegate.cpp
@@ -111,6 +111,9 @@ QString FrequencyDelegate::displayText(const QVariant &value, const QLocale &loc
 
 QWidget* FrequencyDelegate::createEditor(QWidget* parent, const QStyleOptionViewItem& option, const QModelIndex& index) const
 {
+    (void) option;
+    (void) index;
+
     QLineEdit* editor = new QLineEdit(parent);
     QIntValidator* validator = new QIntValidator();
     validator->setBottom(0);
@@ -134,5 +137,6 @@ void FrequencyDelegate::setModelData(QWidget* editor, QAbstractItemModel* model,
 
 void FrequencyDelegate::updateEditorGeometry(QWidget* editor, const QStyleOptionViewItem& option, const QModelIndex& index) const
 {
+    (void) index;
     editor->setGeometry(option.rect);
 }

From 3b0512bd29356474547d74fa0d7775217ed37944 Mon Sep 17 00:00:00 2001
From: srcejon <jon@beniston.com>
Date: Sun, 22 Oct 2023 10:25:40 +0100
Subject: [PATCH 22/23] Fix crash if some columns in .csv file is missing

---
 sdrgui/gui/spectrummarkersdialog.cpp | 26 +++++++++++++++++---------
 1 file changed, 17 insertions(+), 9 deletions(-)

diff --git a/sdrgui/gui/spectrummarkersdialog.cpp b/sdrgui/gui/spectrummarkersdialog.cpp
index 25a765fcd..89fdbfc88 100644
--- a/sdrgui/gui/spectrummarkersdialog.cpp
+++ b/sdrgui/gui/spectrummarkersdialog.cpp
@@ -19,6 +19,7 @@
 #include <QStandardPaths>
 #include <QColorDialog>
 #include <QFileDialog>
+#include <QDebug>
 
 #include "gui/dialpopup.h"
 #include "util/db.h"
@@ -772,15 +773,22 @@ void SpectrumMarkersDialog::on_aMarkersImport_clicked()
 
                     while (CSV::readRow(in, &cols))
                     {
-                        m_annotationMarkers.push_back(SpectrumAnnotationMarker());
-                        m_annotationMarkers.back().m_startFrequency = cols[startCol].toLongLong();
-                        m_annotationMarkers.back().m_bandwidth = cols[widthCol].toUInt();
-                        m_annotationMarkers.back().m_text = cols[textCol];
-                        m_annotationMarkers.back().m_show = (SpectrumAnnotationMarker::ShowState) cols[showCol].toInt();
-                        int r = cols[redCol].toInt();
-                        int g = cols[greenCol].toInt();
-                        int b = cols[blueCol].toInt();
-                        m_annotationMarkers.back().m_markerColor = QColor(r, g, b);
+                        if (cols.size() >= 7)
+                        {
+                            m_annotationMarkers.push_back(SpectrumAnnotationMarker());
+                            m_annotationMarkers.back().m_startFrequency = cols[startCol].toLongLong();
+                            m_annotationMarkers.back().m_bandwidth = cols[widthCol].toUInt();
+                            m_annotationMarkers.back().m_text = cols[textCol];
+                            m_annotationMarkers.back().m_show = (SpectrumAnnotationMarker::ShowState) cols[showCol].toInt();
+                            int r = cols[redCol].toInt();
+                            int g = cols[greenCol].toInt();
+                            int b = cols[blueCol].toInt();
+                            m_annotationMarkers.back().m_markerColor = QColor(r, g, b);
+                        }
+                        else
+                        {
+                            qWarning() << "SpectrumMarkersDialog::on_aMarkersImport_clicked: Missing data in " << cols;
+                        }
                     }
 
                     m_annotationMarkerIndex = 0;

From 842d90f2687b5ae6b5849c756364d32d97695b96 Mon Sep 17 00:00:00 2001
From: Jon Beniston <jon@beniston.com>
Date: Sun, 22 Oct 2023 14:27:06 +0100
Subject: [PATCH 23/23] Update to MacOS 12, as brew complains about 11 being
 unsupported

---
 .github/workflows/sdrangel.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/sdrangel.yml b/.github/workflows/sdrangel.yml
index a26c2e792..a191081fa 100644
--- a/.github/workflows/sdrangel.yml
+++ b/.github/workflows/sdrangel.yml
@@ -100,7 +100,7 @@ jobs:
           files: ${{ github.workspace }}/build/sdrangel-${{ steps.get_version.outputs.version }}-win64.exe
 
   build_mac:
-    runs-on: macos-11
+    runs-on: macos-12
     steps:
       - uses: actions/checkout@v3
         with: