BeamSteeringCWSource renamed to BeamSteeringCWMod

2026-08-14 23:43:43 -04:00 · 2019-10-24 01:23:38 +02:00
parent aeb58ffeab
commit cac5444647
25 changed files with 786 additions and 331 deletions
@@ -1,6 +1,6 @@
 project(channelmimo)

-add_subdirectory(beamsteeringcwsource)
+add_subdirectory(beamsteeringcwmod)

 if (NOT SERVER_MODE)
    add_subdirectory(interferometer)
@@ -0,0 +1,58 @@
+project(beamsteeringcwmod)
+
+set(beamsteeringcwmod_SOURCES
+    beamsteeringcwmodplugin.cpp
+    beamsteeringcwmod.cpp
+    beamsteeringcwmodsettings.cpp
+    beamsteeringcwmodsource.cpp
+    beamsteeringcwmodwebapiadapter.cpp
+)
+
+set(beamsteeringcwmod_HEADERS
+    beamsteeringcwmodplugin.h
+    beamsteeringcwmod.h
+    beamsteeringcwmodsettings.h
+    beamsteeringcwmodsource.h
+    beamsteeringcwmodwebapiadapter.h
+)
+
+include_directories(
+    ${CMAKE_SOURCE_DIR}/swagger/sdrangel/code/qt5/client
+    ${Boost_INCLUDE_DIR}
+)
+
+if (NOT SERVER_MODE)
+    set(beamsteeringcwmod_SOURCES
+        ${beamsteeringcwmod_SOURCES}
+        beamsteeringcwmodgui.cpp
+        beamsteeringcwmodgui.ui
+    )
+    set(beamsteeringcwmod_HEADERS
+        ${beamsteeringcwmod_HEADERS}
+        beamsteeringcwmodgui.h
+    )
+
+    set(TARGET_NAME beamsteeringcwmod)
+    set(TARGET_LIB "Qt5::Widgets")
+    set(TARGET_LIB_GUI "sdrgui")
+    set(INSTALL_FOLDER ${INSTALL_PLUGINS_DIR})
+else()
+    set(TARGET_NAME beamsteeringcwmodsrv)
+    set(TARGET_LIB "")
+    set(TARGET_LIB_GUI "")
+    set(INSTALL_FOLDER ${INSTALL_PLUGINSSRV_DIR})
+endif()
+
+add_library(${TARGET_NAME} SHARED
+    ${beamsteeringcwmod_SOURCES}
+)
+
+target_link_libraries(${TARGET_NAME}
+    Qt5::Core
+    ${TARGET_LIB}
+	sdrbase
+	${TARGET_LIB_GUI}
+    swagger
+)
+
+install(TARGETS ${TARGET_NAME} DESTINATION ${INSTALL_FOLDER})
@@ -29,16 +29,16 @@

 #include "SWGChannelSettings.h"

-#include "beamsteeringcwsourceworker.h"
-#include "beamsteeringcwsource.h"
+#include "beamsteeringcwmodsource.h"
+#include "beamsteeringcwmod.h"

-MESSAGE_CLASS_DEFINITION(BeamSteeringCWSource::MsgConfigureBeamSteeringCWSource, Message)
-MESSAGE_CLASS_DEFINITION(BeamSteeringCWSource::MsgBasebandNotification, Message)
+MESSAGE_CLASS_DEFINITION(BeamSteeringCWMod::MsgConfigureBeamSteeringCWMod, Message)
+MESSAGE_CLASS_DEFINITION(BeamSteeringCWMod::MsgBasebandNotification, Message)

-const QString BeamSteeringCWSource::m_channelIdURI = "sdrangel.channel.beamsteeringcwsource";
-const QString BeamSteeringCWSource::m_channelId = "BeamSteeringCWSource";
+const QString BeamSteeringCWMod::m_channelIdURI = "sdrangel.channel.beamsteeringcwmod";
+const QString BeamSteeringCWMod::m_channelId = "BeamSteeringCWMod";

-BeamSteeringCWSource::BeamSteeringCWSource(DeviceAPI *deviceAPI) :
+BeamSteeringCWMod::BeamSteeringCWMod(DeviceAPI *deviceAPI) :
    ChannelAPI(m_channelIdURI, ChannelAPI::StreamMIMO),
    m_deviceAPI(deviceAPI),
    m_guiMessageQueue(nullptr),
@@ -48,8 +48,8 @@ BeamSteeringCWSource::BeamSteeringCWSource(DeviceAPI *deviceAPI) :
    setObjectName(m_channelId);

    m_thread = new QThread(this);
-    m_sourceWorker = new BeamSteeringCWSourceWorker();
-    m_sourceWorker->moveToThread(m_thread);
+    m_source = new BeamSteeringCWModSource();
+    m_source->moveToThread(m_thread);
    m_deviceAPI->addMIMOChannel(this);
    m_deviceAPI->addMIMOChannelAPI(this);
    connect(&m_inputMessageQueue, SIGNAL(messageEnqueued()), this, SLOT(handleInputMessages()));
@@ -58,44 +58,44 @@ BeamSteeringCWSource::BeamSteeringCWSource(DeviceAPI *deviceAPI) :
    connect(m_networkManager, SIGNAL(finished(QNetworkReply*)), this, SLOT(networkManagerFinished(QNetworkReply*)));
 }

-BeamSteeringCWSource::~BeamSteeringCWSource()
+BeamSteeringCWMod::~BeamSteeringCWMod()
 {
    disconnect(m_networkManager, SIGNAL(finished(QNetworkReply*)), this, SLOT(networkManagerFinished(QNetworkReply*)));
    delete m_networkManager;

    m_deviceAPI->removeChannelSinkAPI(this);
    m_deviceAPI->removeMIMOChannel(this);
-    delete m_sourceWorker;
+    delete m_source;
    delete m_thread;
 }

-void BeamSteeringCWSource::startSources()
+void BeamSteeringCWMod::startSources()
 {
-    m_sourceWorker->reset();
+    m_source->reset();
    m_thread->start();
 }

-void BeamSteeringCWSource::stopSources()
+void BeamSteeringCWMod::stopSources()
 {
 	m_thread->exit();
 	m_thread->wait();
 }

-void BeamSteeringCWSource::pull(const SampleVector::const_iterator& begin, unsigned int nbSamples, unsigned int sourceIndex)
+void BeamSteeringCWMod::pull(const SampleVector::const_iterator& begin, unsigned int nbSamples, unsigned int sourceIndex)
 {
-    m_sourceWorker->pull(begin, nbSamples, sourceIndex);
+    m_source->pull(begin, nbSamples, sourceIndex);
 }

-void BeamSteeringCWSource::feed(const SampleVector::const_iterator& begin, const SampleVector::const_iterator& end, unsigned int sinkIndex)
+void BeamSteeringCWMod::feed(const SampleVector::const_iterator& begin, const SampleVector::const_iterator& end, unsigned int sinkIndex)
 {
    (void) begin;
    (void) end;
    (void) sinkIndex;
 }

-void BeamSteeringCWSource::applySettings(const BeamSteeringCWSourceSettings& settings, bool force)
+void BeamSteeringCWMod::applySettings(const BeamSteeringCWModSettings& settings, bool force)
 {
-    qDebug() << "BeamSteeringCWSource::applySettings: "
+    qDebug() << "BeamSteeringCWMod::applySettings: "
        << "m_steerDegrees: " << settings.m_steerDegrees
        << "m_filterChainHash: " << settings.m_filterChainHash
        << "m_log2Interp: " << settings.m_log2Interp
@@ -109,19 +109,19 @@ void BeamSteeringCWSource::applySettings(const BeamSteeringCWSourceSettings& set
    if ((m_settings.m_log2Interp != settings.m_log2Interp)
     || (m_settings.m_filterChainHash != settings.m_filterChainHash) || force)
    {
-        BeamSteeringCWSourceWorker::MsgConfigureChannelizer *msg = BeamSteeringCWSourceWorker::MsgConfigureChannelizer::create(
+        BeamSteeringCWModSource::MsgConfigureChannelizer *msg = BeamSteeringCWModSource::MsgConfigureChannelizer::create(
            settings.m_log2Interp, settings.m_filterChainHash);
-        m_sourceWorker->getInputMessageQueue()->push(msg);
+        m_source->getInputMessageQueue()->push(msg);
    }

    if ((m_settings.m_steerDegrees != settings.m_steerDegrees) || force) {
-        m_sourceWorker->setSteeringDegrees(settings.m_steerDegrees);
+        m_source->setSteeringDegrees(settings.m_steerDegrees);
    }

    m_settings = settings;
 }

-void BeamSteeringCWSource::handleInputMessages()
+void BeamSteeringCWMod::handleInputMessages()
 {
    Message* message;

@@ -134,12 +134,12 @@ void BeamSteeringCWSource::handleInputMessages()
    }
 }

-bool BeamSteeringCWSource::handleMessage(const Message& cmd)
+bool BeamSteeringCWMod::handleMessage(const Message& cmd)
 {
-    if (MsgConfigureBeamSteeringCWSource::match(cmd))
+    if (MsgConfigureBeamSteeringCWMod::match(cmd))
    {
-        MsgConfigureBeamSteeringCWSource& cfg = (MsgConfigureBeamSteeringCWSource&) cmd;
-        qDebug() << "BeamSteeringCWSource::handleMessage: MsgConfigureBeamSteeringCWSource";
+        MsgConfigureBeamSteeringCWMod& cfg = (MsgConfigureBeamSteeringCWMod&) cmd;
+        qDebug() << "BeamSteeringCWMod::handleMessage: MsgConfigureBeamSteeringCWMod";
        applySettings(cfg.getSettings(), cfg.getForce());
        return true;
    }
@@ -147,7 +147,7 @@ bool BeamSteeringCWSource::handleMessage(const Message& cmd)
    {
        DSPMIMOSignalNotification& notif = (DSPMIMOSignalNotification&) cmd;

-        qDebug() << "BeamSteeringCWSource::handleMessage: DSPMIMOSignalNotification:"
+        qDebug() << "BeamSteeringCWMod::handleMessage: DSPMIMOSignalNotification:"
                << " outputSampleRate: " << notif.getSampleRate()
                << " centerFrequency: " << notif.getCenterFrequency()
                << " sourceElseSink: " << notif.getSourceOrSink()
@@ -159,17 +159,17 @@ bool BeamSteeringCWSource::handleMessage(const Message& cmd)
            calculateFrequencyOffset(); // This is when device sample rate changes

            // Notify sink of input sample rate change
-            BeamSteeringCWSourceWorker::MsgSignalNotification *sig = BeamSteeringCWSourceWorker::MsgSignalNotification::create(
+            BeamSteeringCWModSource::MsgSignalNotification *sig = BeamSteeringCWModSource::MsgSignalNotification::create(
                m_deviceSampleRate, notif.getCenterFrequency(), notif.getIndex()
            );
-            qDebug() << "BeamSteeringCWSource::handleMessage: DSPMIMOSignalNotification: push to worker";
-            m_sourceWorker->getInputMessageQueue()->push(sig);
+            qDebug() << "BeamSteeringCWMod::handleMessage: DSPMIMOSignalNotification: push to worker";
+            m_source->getInputMessageQueue()->push(sig);

            // Redo the channelizer stuff with the new sample rate to re-synchronize everything
-            BeamSteeringCWSourceWorker::MsgConfigureChannelizer *msg = BeamSteeringCWSourceWorker::MsgConfigureChannelizer::create(
+            BeamSteeringCWModSource::MsgConfigureChannelizer *msg = BeamSteeringCWModSource::MsgConfigureChannelizer::create(
                m_settings.m_log2Interp,
                m_settings.m_filterChainHash);
-            m_sourceWorker->getInputMessageQueue()->push(msg);
+            m_source->getInputMessageQueue()->push(msg);

            if (m_guiMessageQueue)
            {
@@ -187,30 +187,30 @@ bool BeamSteeringCWSource::handleMessage(const Message& cmd)
    }
 }

-QByteArray BeamSteeringCWSource::serialize() const
+QByteArray BeamSteeringCWMod::serialize() const
 {
    return m_settings.serialize();
 }

-bool BeamSteeringCWSource::deserialize(const QByteArray& data)
+bool BeamSteeringCWMod::deserialize(const QByteArray& data)
 {
    (void) data;
    if (m_settings.deserialize(data))
    {
-        MsgConfigureBeamSteeringCWSource *msg = MsgConfigureBeamSteeringCWSource::create(m_settings, true);
+        MsgConfigureBeamSteeringCWMod *msg = MsgConfigureBeamSteeringCWMod::create(m_settings, true);
        m_inputMessageQueue.push(msg);
        return true;
    }
    else
    {
        m_settings.resetToDefaults();
-        MsgConfigureBeamSteeringCWSource *msg = MsgConfigureBeamSteeringCWSource::create(m_settings, true);
+        MsgConfigureBeamSteeringCWMod *msg = MsgConfigureBeamSteeringCWMod::create(m_settings, true);
        m_inputMessageQueue.push(msg);
        return false;
    }
 }

-void BeamSteeringCWSource::validateFilterChainHash(BeamSteeringCWSourceSettings& settings)
+void BeamSteeringCWMod::validateFilterChainHash(BeamSteeringCWModSettings& settings)
 {
    unsigned int s = 1;

@@ -221,40 +221,40 @@ void BeamSteeringCWSource::validateFilterChainHash(BeamSteeringCWSourceSettings&
    settings.m_filterChainHash = settings.m_filterChainHash >= s ? s-1 : settings.m_filterChainHash;
 }

-void BeamSteeringCWSource::calculateFrequencyOffset()
+void BeamSteeringCWMod::calculateFrequencyOffset()
 {
    double shiftFactor = HBFilterChainConverter::getShiftFactor(m_settings.m_log2Interp, m_settings.m_filterChainHash);
    m_frequencyOffset = m_deviceSampleRate * shiftFactor;
 }

-void BeamSteeringCWSource::applyChannelSettings(uint32_t log2Interp, uint32_t filterChainHash)
+void BeamSteeringCWMod::applyChannelSettings(uint32_t log2Interp, uint32_t filterChainHash)
 {
-    BeamSteeringCWSourceWorker::MsgConfigureChannelizer *msg = BeamSteeringCWSourceWorker::MsgConfigureChannelizer::create(log2Interp, filterChainHash);
-    m_sourceWorker->getInputMessageQueue()->push(msg);
+    BeamSteeringCWModSource::MsgConfigureChannelizer *msg = BeamSteeringCWModSource::MsgConfigureChannelizer::create(log2Interp, filterChainHash);
+    m_source->getInputMessageQueue()->push(msg);
 }

-int BeamSteeringCWSource::webapiSettingsGet(
+int BeamSteeringCWMod::webapiSettingsGet(
        SWGSDRangel::SWGChannelSettings& response,
        QString& errorMessage)
 {
    (void) errorMessage;
-    response.setBeamSteeringCwSourceSettings(new SWGSDRangel::SWGBeamSteeringCWSourceSettings());
-    response.getBeamSteeringCwSourceSettings()->init();
+    response.setBeamSteeringCwModSettings(new SWGSDRangel::SWGBeamSteeringCWModSettings());
+    response.getBeamSteeringCwModSettings()->init();
    webapiFormatChannelSettings(response, m_settings);
    return 200;
 }

-int BeamSteeringCWSource::webapiSettingsPutPatch(
+int BeamSteeringCWMod::webapiSettingsPutPatch(
        bool force,
        const QStringList& channelSettingsKeys,
        SWGSDRangel::SWGChannelSettings& response,
        QString& errorMessage)
 {
    (void) errorMessage;
-    BeamSteeringCWSourceSettings settings = m_settings;
+    BeamSteeringCWModSettings settings = m_settings;
    webapiUpdateChannelSettings(settings, channelSettingsKeys, response);

-    MsgConfigureBeamSteeringCWSource *msg = MsgConfigureBeamSteeringCWSource::create(settings, force);
+    MsgConfigureBeamSteeringCWMod *msg = MsgConfigureBeamSteeringCWMod::create(settings, force);
    m_inputMessageQueue.push(msg);

    webapiFormatChannelSettings(response, settings);
@@ -262,83 +262,83 @@ int BeamSteeringCWSource::webapiSettingsPutPatch(
    return 200;
 }

-void BeamSteeringCWSource::webapiUpdateChannelSettings(
-        BeamSteeringCWSourceSettings& settings,
+void BeamSteeringCWMod::webapiUpdateChannelSettings(
+        BeamSteeringCWModSettings& settings,
        const QStringList& channelSettingsKeys,
        SWGSDRangel::SWGChannelSettings& response)
 {
    if (channelSettingsKeys.contains("steerDegrees")) {
-        settings.m_rgbColor = response.getBeamSteeringCwSourceSettings()->getSteerDegrees();
+        settings.m_rgbColor = response.getBeamSteeringCwModSettings()->getSteerDegrees();
    }

    if (channelSettingsKeys.contains("rgbColor")) {
-        settings.m_rgbColor = response.getBeamSteeringCwSourceSettings()->getRgbColor();
+        settings.m_rgbColor = response.getBeamSteeringCwModSettings()->getRgbColor();
    }
    if (channelSettingsKeys.contains("title")) {
-        settings.m_title = *response.getBeamSteeringCwSourceSettings()->getTitle();
+        settings.m_title = *response.getBeamSteeringCwModSettings()->getTitle();
    }
    if (channelSettingsKeys.contains("log2Interp")) {
-        settings.m_log2Interp = response.getBeamSteeringCwSourceSettings()->getLog2Interp();
+        settings.m_log2Interp = response.getBeamSteeringCwModSettings()->getLog2Interp();
    }

    if (channelSettingsKeys.contains("filterChainHash"))
    {
-        settings.m_filterChainHash = response.getBeamSteeringCwSourceSettings()->getFilterChainHash();
+        settings.m_filterChainHash = response.getBeamSteeringCwModSettings()->getFilterChainHash();
        validateFilterChainHash(settings);
    }

    if (channelSettingsKeys.contains("useReverseAPI")) {
-        settings.m_useReverseAPI = response.getBeamSteeringCwSourceSettings()->getUseReverseApi() != 0;
+        settings.m_useReverseAPI = response.getBeamSteeringCwModSettings()->getUseReverseApi() != 0;
    }
    if (channelSettingsKeys.contains("reverseAPIAddress")) {
-        settings.m_reverseAPIAddress = *response.getBeamSteeringCwSourceSettings()->getReverseApiAddress();
+        settings.m_reverseAPIAddress = *response.getBeamSteeringCwModSettings()->getReverseApiAddress();
    }
    if (channelSettingsKeys.contains("reverseAPIPort")) {
-        settings.m_reverseAPIPort = response.getBeamSteeringCwSourceSettings()->getReverseApiPort();
+        settings.m_reverseAPIPort = response.getBeamSteeringCwModSettings()->getReverseApiPort();
    }
    if (channelSettingsKeys.contains("reverseAPIDeviceIndex")) {
-        settings.m_reverseAPIDeviceIndex = response.getBeamSteeringCwSourceSettings()->getReverseApiDeviceIndex();
+        settings.m_reverseAPIDeviceIndex = response.getBeamSteeringCwModSettings()->getReverseApiDeviceIndex();
    }
    if (channelSettingsKeys.contains("reverseAPIChannelIndex")) {
-        settings.m_reverseAPIChannelIndex = response.getBeamSteeringCwSourceSettings()->getReverseApiChannelIndex();
+        settings.m_reverseAPIChannelIndex = response.getBeamSteeringCwModSettings()->getReverseApiChannelIndex();
    }
 }

-void BeamSteeringCWSource::webapiFormatChannelSettings(SWGSDRangel::SWGChannelSettings& response, const BeamSteeringCWSourceSettings& settings)
+void BeamSteeringCWMod::webapiFormatChannelSettings(SWGSDRangel::SWGChannelSettings& response, const BeamSteeringCWModSettings& settings)
 {
-    response.getBeamSteeringCwSourceSettings()->setSteerDegrees(settings.m_steerDegrees);
-    response.getBeamSteeringCwSourceSettings()->setRgbColor(settings.m_rgbColor);
+    response.getBeamSteeringCwModSettings()->setSteerDegrees(settings.m_steerDegrees);
+    response.getBeamSteeringCwModSettings()->setRgbColor(settings.m_rgbColor);

-    if (response.getBeamSteeringCwSourceSettings()->getTitle()) {
-        *response.getBeamSteeringCwSourceSettings()->getTitle() = settings.m_title;
+    if (response.getBeamSteeringCwModSettings()->getTitle()) {
+        *response.getBeamSteeringCwModSettings()->getTitle() = settings.m_title;
    } else {
-        response.getBeamSteeringCwSourceSettings()->setTitle(new QString(settings.m_title));
+        response.getBeamSteeringCwModSettings()->setTitle(new QString(settings.m_title));
    }

-    response.getBeamSteeringCwSourceSettings()->setLog2Interp(settings.m_log2Interp);
-    response.getBeamSteeringCwSourceSettings()->setFilterChainHash(settings.m_filterChainHash);
-    response.getBeamSteeringCwSourceSettings()->setUseReverseApi(settings.m_useReverseAPI ? 1 : 0);
+    response.getBeamSteeringCwModSettings()->setLog2Interp(settings.m_log2Interp);
+    response.getBeamSteeringCwModSettings()->setFilterChainHash(settings.m_filterChainHash);
+    response.getBeamSteeringCwModSettings()->setUseReverseApi(settings.m_useReverseAPI ? 1 : 0);

-    if (response.getBeamSteeringCwSourceSettings()->getReverseApiAddress()) {
-        *response.getBeamSteeringCwSourceSettings()->getReverseApiAddress() = settings.m_reverseAPIAddress;
+    if (response.getBeamSteeringCwModSettings()->getReverseApiAddress()) {
+        *response.getBeamSteeringCwModSettings()->getReverseApiAddress() = settings.m_reverseAPIAddress;
    } else {
-        response.getBeamSteeringCwSourceSettings()->setReverseApiAddress(new QString(settings.m_reverseAPIAddress));
+        response.getBeamSteeringCwModSettings()->setReverseApiAddress(new QString(settings.m_reverseAPIAddress));
    }

-    response.getBeamSteeringCwSourceSettings()->setReverseApiPort(settings.m_reverseAPIPort);
-    response.getBeamSteeringCwSourceSettings()->setReverseApiDeviceIndex(settings.m_reverseAPIDeviceIndex);
-    response.getBeamSteeringCwSourceSettings()->setReverseApiChannelIndex(settings.m_reverseAPIChannelIndex);
+    response.getBeamSteeringCwModSettings()->setReverseApiPort(settings.m_reverseAPIPort);
+    response.getBeamSteeringCwModSettings()->setReverseApiDeviceIndex(settings.m_reverseAPIDeviceIndex);
+    response.getBeamSteeringCwModSettings()->setReverseApiChannelIndex(settings.m_reverseAPIChannelIndex);
 }

-void BeamSteeringCWSource::webapiReverseSendSettings(QList<QString>& channelSettingsKeys, const BeamSteeringCWSourceSettings& settings, bool force)
+void BeamSteeringCWMod::webapiReverseSendSettings(QList<QString>& channelSettingsKeys, const BeamSteeringCWModSettings& settings, bool force)
 {
    SWGSDRangel::SWGChannelSettings *swgChannelSettings = new SWGSDRangel::SWGChannelSettings();
    swgChannelSettings->setDirection(2); // MIMO sink
    swgChannelSettings->setOriginatorChannelIndex(getIndexInDeviceSet());
    swgChannelSettings->setOriginatorDeviceSetIndex(getDeviceSetIndex());
    swgChannelSettings->setChannelType(new QString("BeamSteeringCWSource"));
-    swgChannelSettings->setBeamSteeringCwSourceSettings(new SWGSDRangel::SWGBeamSteeringCWSourceSettings());
-    SWGSDRangel::SWGBeamSteeringCWSourceSettings *swgBeamSteeringCWSettings = swgChannelSettings->getBeamSteeringCwSourceSettings();
+    swgChannelSettings->setBeamSteeringCwModSettings(new SWGSDRangel::SWGBeamSteeringCWModSettings());
+    SWGSDRangel::SWGBeamSteeringCWModSettings *swgBeamSteeringCWSettings = swgChannelSettings->getBeamSteeringCwModSettings();

    // transfer data that has been modified. When force is on transfer all data except reverse API data

@@ -377,13 +377,13 @@ void BeamSteeringCWSource::webapiReverseSendSettings(QList<QString>& channelSett
    delete swgChannelSettings;
 }

-void BeamSteeringCWSource::networkManagerFinished(QNetworkReply *reply)
+void BeamSteeringCWMod::networkManagerFinished(QNetworkReply *reply)
 {
    QNetworkReply::NetworkError replyError = reply->error();

    if (replyError)
    {
-        qWarning() << "BeamSteeringCWSource::networkManagerFinished:"
+        qWarning() << "BeamSteeringCWMod::networkManagerFinished:"
                << " error(" << (int) replyError
                << "): " << replyError
                << ": " << reply->errorString();
@@ -392,5 +392,5 @@ void BeamSteeringCWSource::networkManagerFinished(QNetworkReply *reply)

    QString answer = reply->readAll();
    answer.chop(1); // remove last \n
-    qDebug("BeamSteeringCWSource::networkManagerFinished: reply:\n%s", answer.toStdString().c_str());
+    qDebug("BeamSteeringCWMod::networkManagerFinished: reply:\n%s", answer.toStdString().c_str());
 }
@@ -15,8 +15,8 @@
 // along with this program. If not, see <http://www.gnu.org/licenses/>.          //
 ///////////////////////////////////////////////////////////////////////////////////

-#ifndef INCLUDE_BEAMSTEERINGCWSOURCE_H
-#define INCLUDE_BEAMSTEERINGCWSOURCE_H
+#ifndef INCLUDE_BEAMSTEERINGCWMOD_H
+#define INCLUDE_BEAMSTEERINGCWMOD_H

 #include <vector>
 #include <QNetworkRequest>
@@ -26,36 +26,36 @@
 #include "util/messagequeue.h"
 #include "util/message.h"

-#include "beamsteeringcwsourcesettings.h"
+#include "beamsteeringcwmodsettings.h"

 class QThread;
 class DeviceAPI;
-class BeamSteeringCWSourceWorker;
+class BeamSteeringCWModSource;
 class QNetworkReply;
 class QNetworkAccessManager;
 class BasebandSampleSink;

-class BeamSteeringCWSource: public MIMOChannel, public ChannelAPI
+class BeamSteeringCWMod: public MIMOChannel, public ChannelAPI
 {
    Q_OBJECT
 public:
-    class MsgConfigureBeamSteeringCWSource : public Message {
+    class MsgConfigureBeamSteeringCWMod : public Message {
        MESSAGE_CLASS_DECLARATION

    public:
-        const BeamSteeringCWSourceSettings& getSettings() const { return m_settings; }
+        const BeamSteeringCWModSettings& getSettings() const { return m_settings; }
        bool getForce() const { return m_force; }

-        static MsgConfigureBeamSteeringCWSource* create(const BeamSteeringCWSourceSettings& settings, bool force)
+        static MsgConfigureBeamSteeringCWMod* create(const BeamSteeringCWModSettings& settings, bool force)
        {
-            return new MsgConfigureBeamSteeringCWSource(settings, force);
+            return new MsgConfigureBeamSteeringCWMod(settings, force);
        }

    private:
-        BeamSteeringCWSourceSettings m_settings;
+        BeamSteeringCWModSettings m_settings;
        bool m_force;

-        MsgConfigureBeamSteeringCWSource(const BeamSteeringCWSourceSettings& settings, bool force) :
+        MsgConfigureBeamSteeringCWMod(const BeamSteeringCWModSettings& settings, bool force) :
            Message(),
            m_settings(settings),
            m_force(force)
@@ -85,8 +85,8 @@ public:
        qint64 m_centerFrequency;
    };

-    BeamSteeringCWSource(DeviceAPI *deviceAPI);
-	virtual ~BeamSteeringCWSource();
+    BeamSteeringCWMod(DeviceAPI *deviceAPI);
+	virtual ~BeamSteeringCWMod();
 	virtual void destroy() { delete this; }

 	virtual void startSinks() {}
@@ -98,7 +98,7 @@ public:
 	virtual bool handleMessage(const Message& cmd); //!< Processing of a message. Returns true if message has actually been processed

    virtual void getIdentifier(QString& id) { id = objectName(); }
-    virtual void getTitle(QString& title) { title = "BeamSteeringCWSource"; }
+    virtual void getTitle(QString& title) { title = "BeamSteeringCWMod"; }
    virtual qint64 getCenterFrequency() const { return m_frequencyOffset; }

    virtual QByteArray serialize() const;
@@ -132,10 +132,10 @@ public:

    static void webapiFormatChannelSettings(
        SWGSDRangel::SWGChannelSettings& response,
-        const BeamSteeringCWSourceSettings& settings);
+        const BeamSteeringCWModSettings& settings);

    static void webapiUpdateChannelSettings(
-            BeamSteeringCWSourceSettings& settings,
+            BeamSteeringCWModSettings& settings,
            const QStringList& channelSettingsKeys,
            SWGSDRangel::SWGChannelSettings& response);

@@ -146,10 +146,10 @@ public:
 private:
    DeviceAPI *m_deviceAPI;
    QThread *m_thread;
-    BeamSteeringCWSourceWorker* m_sourceWorker;
+    BeamSteeringCWModSource* m_source;
    BasebandSampleSink* m_spectrumSink;
    BasebandSampleSink* m_scopeSink;
-    BeamSteeringCWSourceSettings m_settings;
+    BeamSteeringCWModSettings m_settings;
 	MessageQueue m_inputMessageQueue; //!< Queue for asynchronous inbound communication
    MessageQueue *m_guiMessageQueue;  //!< Input message queue to the GUI

@@ -160,10 +160,10 @@ private:
    uint32_t m_deviceSampleRate;
    int m_count0, m_count1;

-    void applySettings(const BeamSteeringCWSourceSettings& settings, bool force = false);
-    static void validateFilterChainHash(BeamSteeringCWSourceSettings& settings);
+    void applySettings(const BeamSteeringCWModSettings& settings, bool force = false);
+    static void validateFilterChainHash(BeamSteeringCWModSettings& settings);
    void calculateFrequencyOffset();
-    void webapiReverseSendSettings(QList<QString>& channelSettingsKeys, const BeamSteeringCWSourceSettings& settings, bool force);
+    void webapiReverseSendSettings(QList<QString>& channelSettingsKeys, const BeamSteeringCWModSettings& settings, bool force);

 private slots:
    void handleInputMessages();
@@ -22,53 +22,53 @@
 #include "dsp/hbfilterchainconverter.h"
 #include "mainwindow.h"

-#include "beamsteeringcwsourcegui.h"
-#include "beamsteeringcwsource.h"
-#include "ui_beamsteeringcwsourcegui.h"
+#include "beamsteeringcwmodgui.h"
+#include "beamsteeringcwmod.h"
+#include "ui_beamsteeringcwmodgui.h"

-BeamSteeringCWSourceGUI* BeamSteeringCWSourceGUI::create(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, MIMOChannel *mimoChannel)
+BeamSteeringCWModGUI* BeamSteeringCWModGUI::create(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, MIMOChannel *mimoChannel)
 {
-    BeamSteeringCWSourceGUI* gui = new BeamSteeringCWSourceGUI(pluginAPI, deviceUISet, mimoChannel);
+    BeamSteeringCWModGUI* gui = new BeamSteeringCWModGUI(pluginAPI, deviceUISet, mimoChannel);
    return gui;
 }

-void BeamSteeringCWSourceGUI::destroy()
+void BeamSteeringCWModGUI::destroy()
 {
    delete this;
 }

-void BeamSteeringCWSourceGUI::setName(const QString& name)
+void BeamSteeringCWModGUI::setName(const QString& name)
 {
    setObjectName(name);
 }

-QString BeamSteeringCWSourceGUI::getName() const
+QString BeamSteeringCWModGUI::getName() const
 {
    return objectName();
 }

-qint64 BeamSteeringCWSourceGUI::getCenterFrequency() const {
+qint64 BeamSteeringCWModGUI::getCenterFrequency() const {
    return 0;
 }

-void BeamSteeringCWSourceGUI::setCenterFrequency(qint64 centerFrequency)
+void BeamSteeringCWModGUI::setCenterFrequency(qint64 centerFrequency)
 {
    (void) centerFrequency;
 }

-void BeamSteeringCWSourceGUI::resetToDefaults()
+void BeamSteeringCWModGUI::resetToDefaults()
 {
    m_settings.resetToDefaults();
    displaySettings();
    applySettings(true);
 }

-QByteArray BeamSteeringCWSourceGUI::serialize() const
+QByteArray BeamSteeringCWModGUI::serialize() const
 {
    return m_settings.serialize();
 }

-bool BeamSteeringCWSourceGUI::deserialize(const QByteArray& data)
+bool BeamSteeringCWModGUI::deserialize(const QByteArray& data)
 {
    if(m_settings.deserialize(data)) {
        displaySettings();
@@ -80,19 +80,19 @@ bool BeamSteeringCWSourceGUI::deserialize(const QByteArray& data)
    }
 }

-bool BeamSteeringCWSourceGUI::handleMessage(const Message& message)
+bool BeamSteeringCWModGUI::handleMessage(const Message& message)
 {
-    if (BeamSteeringCWSource::MsgBasebandNotification::match(message))
+    if (BeamSteeringCWMod::MsgBasebandNotification::match(message))
    {
-        BeamSteeringCWSource::MsgBasebandNotification& notif = (BeamSteeringCWSource::MsgBasebandNotification&) message;
+        BeamSteeringCWMod::MsgBasebandNotification& notif = (BeamSteeringCWMod::MsgBasebandNotification&) message;
        m_sampleRate = notif.getSampleRate();
        m_centerFrequency = notif.getCenterFrequency();
        displayRateAndShift();
        return true;
    }
-    else if (BeamSteeringCWSource::MsgConfigureBeamSteeringCWSource::match(message))
+    else if (BeamSteeringCWMod::MsgConfigureBeamSteeringCWMod::match(message))
    {
-        const BeamSteeringCWSource::MsgConfigureBeamSteeringCWSource& cfg = (BeamSteeringCWSource::MsgConfigureBeamSteeringCWSource&) message;
+        const BeamSteeringCWMod::MsgConfigureBeamSteeringCWMod& cfg = (BeamSteeringCWMod::MsgConfigureBeamSteeringCWMod&) message;
        m_settings = cfg.getSettings();
        blockApplySettings(true);
        displaySettings();
@@ -105,9 +105,9 @@ bool BeamSteeringCWSourceGUI::handleMessage(const Message& message)
    }
 }

-BeamSteeringCWSourceGUI::BeamSteeringCWSourceGUI(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, MIMOChannel *mimoChannel, QWidget* parent) :
+BeamSteeringCWModGUI::BeamSteeringCWModGUI(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, MIMOChannel *mimoChannel, QWidget* parent) :
        RollupWidget(parent),
-        ui(new Ui::BeamSteeringCWSourceGUI),
+        ui(new Ui::BeamSteeringCWModGUI),
        m_pluginAPI(pluginAPI),
        m_deviceUISet(deviceUISet),
        m_sampleRate(0),
@@ -118,7 +118,7 @@ BeamSteeringCWSourceGUI::BeamSteeringCWSourceGUI(PluginAPI* pluginAPI, DeviceUIS
    connect(this, SIGNAL(widgetRolled(QWidget*,bool)), this, SLOT(onWidgetRolled(QWidget*,bool)));
    connect(this, SIGNAL(customContextMenuRequested(const QPoint &)), this, SLOT(onMenuDialogCalled(const QPoint &)));

-    m_bsCWSource = (BeamSteeringCWSource*) mimoChannel;
+    m_bsCWSource = (BeamSteeringCWMod*) mimoChannel;
    m_bsCWSource->setMessageQueueToGUI(getInputMessageQueue());

    m_channelMarker.blockSignals(true);
@@ -131,7 +131,7 @@ BeamSteeringCWSourceGUI::BeamSteeringCWSourceGUI(PluginAPI* pluginAPI, DeviceUIS

    m_settings.setChannelMarker(&m_channelMarker);

-    m_deviceUISet->registerChannelInstance(BeamSteeringCWSource::m_channelIdURI, this);
+    m_deviceUISet->registerChannelInstance(BeamSteeringCWMod::m_channelIdURI, this);
    m_deviceUISet->addChannelMarker(&m_channelMarker);
    m_deviceUISet->addRollupWidget(this);

@@ -144,30 +144,30 @@ BeamSteeringCWSourceGUI::BeamSteeringCWSourceGUI(PluginAPI* pluginAPI, DeviceUIS
    applySettings(true);
 }

-BeamSteeringCWSourceGUI::~BeamSteeringCWSourceGUI()
+BeamSteeringCWModGUI::~BeamSteeringCWModGUI()
 {
    m_deviceUISet->removeChannelInstance(this);
    delete m_bsCWSource; // TODO: check this: when the GUI closes it has to delete the demodulator
    delete ui;
 }

-void BeamSteeringCWSourceGUI::blockApplySettings(bool block)
+void BeamSteeringCWModGUI::blockApplySettings(bool block)
 {
    m_doApplySettings = !block;
 }

-void BeamSteeringCWSourceGUI::applySettings(bool force)
+void BeamSteeringCWModGUI::applySettings(bool force)
 {
    if (m_doApplySettings)
    {
        setTitleColor(m_channelMarker.getColor());

-        BeamSteeringCWSource::MsgConfigureBeamSteeringCWSource* message = BeamSteeringCWSource::MsgConfigureBeamSteeringCWSource::create(m_settings, force);
+        BeamSteeringCWMod::MsgConfigureBeamSteeringCWMod* message = BeamSteeringCWMod::MsgConfigureBeamSteeringCWMod::create(m_settings, force);
        m_bsCWSource->getInputMessageQueue()->push(message);
    }
 }

-void BeamSteeringCWSourceGUI::displaySettings()
+void BeamSteeringCWModGUI::displaySettings()
 {
    m_channelMarker.blockSignals(true);
    m_channelMarker.setCenterFrequency(0);
@@ -186,7 +186,7 @@ void BeamSteeringCWSourceGUI::displaySettings()
    blockApplySettings(false);
 }

-void BeamSteeringCWSourceGUI::displayRateAndShift()
+void BeamSteeringCWModGUI::displayRateAndShift()
 {
    int shift = m_shiftFrequencyFactor * m_sampleRate;
    double channelSampleRate = ((double) m_sampleRate) / (1<<m_settings.m_log2Interp);
@@ -197,17 +197,17 @@ void BeamSteeringCWSourceGUI::displayRateAndShift()
    m_channelMarker.setBandwidth(channelSampleRate);
 }

-void BeamSteeringCWSourceGUI::leaveEvent(QEvent*)
+void BeamSteeringCWModGUI::leaveEvent(QEvent*)
 {
    m_channelMarker.setHighlighted(false);
 }

-void BeamSteeringCWSourceGUI::enterEvent(QEvent*)
+void BeamSteeringCWModGUI::enterEvent(QEvent*)
 {
    m_channelMarker.setHighlighted(true);
 }

-void BeamSteeringCWSourceGUI::handleSourceMessages()
+void BeamSteeringCWModGUI::handleSourceMessages()
 {
    Message* message;

@@ -220,13 +220,13 @@ void BeamSteeringCWSourceGUI::handleSourceMessages()
    }
 }

-void BeamSteeringCWSourceGUI::onWidgetRolled(QWidget* widget, bool rollDown)
+void BeamSteeringCWModGUI::onWidgetRolled(QWidget* widget, bool rollDown)
 {
    (void) widget;
    (void) rollDown;
 }

-void BeamSteeringCWSourceGUI::onMenuDialogCalled(const QPoint &p)
+void BeamSteeringCWModGUI::onMenuDialogCalled(const QPoint &p)
 {
    if (m_contextMenuType == ContextMenuChannelSettings)
    {
@@ -257,19 +257,19 @@ void BeamSteeringCWSourceGUI::onMenuDialogCalled(const QPoint &p)
    resetContextMenuType();
 }

-void BeamSteeringCWSourceGUI::on_interpolationFactor_currentIndexChanged(int index)
+void BeamSteeringCWModGUI::on_interpolationFactor_currentIndexChanged(int index)
 {
    m_settings.m_log2Interp = index;
    applyInterpolation();
 }

-void BeamSteeringCWSourceGUI::on_position_valueChanged(int value)
+void BeamSteeringCWModGUI::on_position_valueChanged(int value)
 {
    m_settings.m_filterChainHash = value;
    applyPosition();
 }

-void BeamSteeringCWSourceGUI::applyInterpolation()
+void BeamSteeringCWModGUI::applyInterpolation()
 {
    uint32_t maxHash = 1;

@@ -283,7 +283,7 @@ void BeamSteeringCWSourceGUI::applyInterpolation()
    applyPosition();
 }

-void BeamSteeringCWSourceGUI::applyPosition()
+void BeamSteeringCWModGUI::applyPosition()
 {
    ui->filterChainIndex->setText(tr("%1").arg(m_settings.m_filterChainHash));
    QString s;
@@ -294,7 +294,7 @@ void BeamSteeringCWSourceGUI::applyPosition()
    applySettings();
 }

-void BeamSteeringCWSourceGUI::tick()
+void BeamSteeringCWModGUI::tick()
 {
    if (++m_tickCount == 20) { // once per second
        m_tickCount = 0;
@@ -15,8 +15,8 @@
 // along with this program. If not, see <http://www.gnu.org/licenses/>.          //
 ///////////////////////////////////////////////////////////////////////////////////

-#ifndef INCLUDE_BEAMSTEERINGCWSOURCEGUI_H_
-#define INCLUDE_BEAMSTEERINGCWSOURCEGUI_H_
+#ifndef INCLUDE_BEAMSTEERINGCWMODGUI_H_
+#define INCLUDE_BEAMSTEERINGCWMODGUI_H_

 #include <stdint.h>

@@ -28,21 +28,21 @@
 #include "gui/rollupwidget.h"
 #include "util/messagequeue.h"

-#include "beamsteeringcwsourcesettings.h"
+#include "beamsteeringcwmodsettings.h"

 class PluginAPI;
 class DeviceUISet;
-class BeamSteeringCWSource;
+class BeamSteeringCWMod;
 class MIMOChannel;

 namespace Ui {
-    class BeamSteeringCWSourceGUI;
+    class BeamSteeringCWModGUI;
 }

-class BeamSteeringCWSourceGUI : public RollupWidget, public PluginInstanceGUI {
+class BeamSteeringCWModGUI : public RollupWidget, public PluginInstanceGUI {
    Q_OBJECT
 public:
-    static BeamSteeringCWSourceGUI* create(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, MIMOChannel *mimoChannel);
+    static BeamSteeringCWModGUI* create(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, MIMOChannel *mimoChannel);

    virtual void destroy();
    void setName(const QString& name);
@@ -56,24 +56,24 @@ public:
    virtual bool handleMessage(const Message& message);

 private:
-    Ui::BeamSteeringCWSourceGUI* ui;
+    Ui::BeamSteeringCWModGUI* ui;
    PluginAPI* m_pluginAPI;
    DeviceUISet* m_deviceUISet;
    ChannelMarker m_channelMarker;
-    BeamSteeringCWSourceSettings m_settings;
+    BeamSteeringCWModSettings m_settings;
    int m_sampleRate;
    qint64 m_centerFrequency;
    double m_shiftFrequencyFactor; //!< Channel frequency shift factor
    bool m_doApplySettings;

-    BeamSteeringCWSource* m_bsCWSource;
+    BeamSteeringCWMod* m_bsCWSource;
    MessageQueue m_inputMessageQueue;

    QTime m_time;
    uint32_t m_tickCount;

-    explicit BeamSteeringCWSourceGUI(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, MIMOChannel *mimoChannel, QWidget* parent = nullptr);
-    virtual ~BeamSteeringCWSourceGUI();
+    explicit BeamSteeringCWModGUI(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, MIMOChannel *mimoChannel, QWidget* parent = nullptr);
+    virtual ~BeamSteeringCWModGUI();

    void blockApplySettings(bool block);
    void applySettings(bool force = false);
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
- <class>BeamSteeringCWSourceGUI</class>
- <widget class="RollupWidget" name="BeamSteeringCWSourceGUI">
+ <class>BeamSteeringCWModGUI</class>
+ <widget class="RollupWidget" name="BeamSteeringCWModGUI">
  <property name="geometry">
   <rect>
    <x>0</x>
@@ -15,20 +15,19 @@
 // along with this program. If not, see <http://www.gnu.org/licenses/>.          //
 ///////////////////////////////////////////////////////////////////////////////////

-#include "beamsteeringcwsourceplugin.h"

 #include <QtPlugin>
 #include "plugin/pluginapi.h"

 #ifndef SERVER_MODE
-#include "beamsteeringcwsourcegui.h"
+#include "beamsteeringcwmodgui.h"
 #endif
-#include "beamsteeringcwsource.h"
-#include "beamsteeringcwsourcewebapiadapter.h"
-#include "beamsteeringcwsourceplugin.h"
+#include "beamsteeringcwmod.h"
+#include "beamsteeringcwmodwebapiadapter.h"
+#include "beamsteeringcwmodplugin.h"

-const PluginDescriptor BeamSteeringCWSourcePlugin::m_pluginDescriptor = {
-    QString("BeamSteeringCWSource"),
+const PluginDescriptor BeamSteeringCWModPlugin::m_pluginDescriptor = {
+    QString("BeamSteeringCWMod"),
    QString("5.0.0"),
    QString("(c) Edouard Griffiths, F4EXB"),
    QString("https://github.com/f4exb/sdrangel"),
@@ -36,50 +35,50 @@ const PluginDescriptor BeamSteeringCWSourcePlugin::m_pluginDescriptor = {
    QString("https://github.com/f4exb/sdrangel")
 };

-BeamSteeringCWSourcePlugin::BeamSteeringCWSourcePlugin(QObject* parent) :
+BeamSteeringCWModPlugin::BeamSteeringCWModPlugin(QObject* parent) :
    QObject(parent),
    m_pluginAPI(nullptr)
 {
 }

-const PluginDescriptor& BeamSteeringCWSourcePlugin::getPluginDescriptor() const
+const PluginDescriptor& BeamSteeringCWModPlugin::getPluginDescriptor() const
 {
    return m_pluginDescriptor;
 }

-void BeamSteeringCWSourcePlugin::initPlugin(PluginAPI* pluginAPI)
+void BeamSteeringCWModPlugin::initPlugin(PluginAPI* pluginAPI)
 {
    m_pluginAPI = pluginAPI;

    // register channel MIMO
-    m_pluginAPI->registerMIMOChannel(BeamSteeringCWSource::m_channelIdURI, BeamSteeringCWSource::m_channelId, this);
+    m_pluginAPI->registerMIMOChannel(BeamSteeringCWMod::m_channelIdURI, BeamSteeringCWMod::m_channelId, this);
 }

 #ifdef SERVER_MODE
-PluginInstanceGUI* BeamSteeringCWSourcePlugin::createMIMOChannelGUI(
+PluginInstanceGUI* BeamSteeringCWModPlugin::createMIMOChannelGUI(
        DeviceUISet *deviceUISet,
        MIMOChannel *mimoChannel) const
 {
    return nullptr;
 }
 #else
-PluginInstanceGUI* BeamSteeringCWSourcePlugin::createMIMOChannelGUI(DeviceUISet *deviceUISet, MIMOChannel *mimoChannel) const
+PluginInstanceGUI* BeamSteeringCWModPlugin::createMIMOChannelGUI(DeviceUISet *deviceUISet, MIMOChannel *mimoChannel) const
 {
-    return BeamSteeringCWSourceGUI::create(m_pluginAPI, deviceUISet, mimoChannel);
+    return BeamSteeringCWModGUI::create(m_pluginAPI, deviceUISet, mimoChannel);
 }
 #endif

-MIMOChannel* BeamSteeringCWSourcePlugin::createMIMOChannelBS(DeviceAPI *deviceAPI) const
+MIMOChannel* BeamSteeringCWModPlugin::createMIMOChannelBS(DeviceAPI *deviceAPI) const
 {
-    return new BeamSteeringCWSource(deviceAPI);
+    return new BeamSteeringCWMod(deviceAPI);
 }

-ChannelAPI* BeamSteeringCWSourcePlugin::createMIMOChannelCS(DeviceAPI *deviceAPI) const
+ChannelAPI* BeamSteeringCWModPlugin::createMIMOChannelCS(DeviceAPI *deviceAPI) const
 {
-    return new BeamSteeringCWSource(deviceAPI);
+    return new BeamSteeringCWMod(deviceAPI);
 }

-ChannelWebAPIAdapter* BeamSteeringCWSourcePlugin::createChannelWebAPIAdapter() const
+ChannelWebAPIAdapter* BeamSteeringCWModPlugin::createChannelWebAPIAdapter() const
 {
-	return new BeamSteeringCWSourceWebAPIAdapter();
+	return new BeamSteeringCWModWebAPIAdapter();
 }
@@ -15,8 +15,8 @@
 // along with this program. If not, see <http://www.gnu.org/licenses/>.          //
 ///////////////////////////////////////////////////////////////////////////////////

-#ifndef INCLUDE_BEAMSTEERINGCWSOURCEPLUGIN_H_
-#define INCLUDE_BEAMSTEERINGCWSOURCEPLUGIN_H_
+#ifndef INCLUDE_BEAMSTEERINGCWMODPLUGIN_H_
+#define INCLUDE_BEAMSTEERINGCWMODPLUGIN_H_


 #include <QObject>
@@ -25,13 +25,13 @@
 class DeviceUISet;
 class MIMOChannel;

-class BeamSteeringCWSourcePlugin : public QObject, PluginInterface {
+class BeamSteeringCWModPlugin : public QObject, PluginInterface {
    Q_OBJECT
    Q_INTERFACES(PluginInterface)
-    Q_PLUGIN_METADATA(IID "sdrangel.channelmimo.beamsteeringcwsource")
+    Q_PLUGIN_METADATA(IID "sdrangel.channelmimo.beamsteeringcwmod")

 public:
-    explicit BeamSteeringCWSourcePlugin(QObject* parent = nullptr);
+    explicit BeamSteeringCWModPlugin(QObject* parent = nullptr);

    const PluginDescriptor& getPluginDescriptor() const;
    void initPlugin(PluginAPI* pluginAPI);
@@ -47,4 +47,4 @@ private:
    PluginAPI* m_pluginAPI;
 };

-#endif /* INCLUDE_BEAMSTEERINGCWSOURCEPLUGIN_H_ */
+#endif /* INCLUDE_BEAMSTEERINGCWMODPLUGIN_H_ */
@@ -15,7 +15,7 @@
 // along with this program. If not, see <http://www.gnu.org/licenses/>.          //
 ///////////////////////////////////////////////////////////////////////////////////

-#include "beamsteeringcwsourcesettings.h"
+#include "beamsteeringcwmodsettings.h"

 #include <QColor>

@@ -23,12 +23,12 @@
 #include "settings/serializable.h"


-BeamSteeringCWSourceSettings::BeamSteeringCWSourceSettings()
+BeamSteeringCWModSettings::BeamSteeringCWModSettings()
 {
    resetToDefaults();
 }

-void BeamSteeringCWSourceSettings::resetToDefaults()
+void BeamSteeringCWModSettings::resetToDefaults()
 {
    m_steerDegrees = 90;
    m_rgbColor = QColor(140, 4, 4).rgb();
@@ -43,7 +43,7 @@ void BeamSteeringCWSourceSettings::resetToDefaults()
    m_reverseAPIChannelIndex = 0;
 }

-QByteArray BeamSteeringCWSourceSettings::serialize() const
+QByteArray BeamSteeringCWModSettings::serialize() const
 {
    SimpleSerializer s(1);
    s.writeS32(1, m_steerDegrees);
@@ -60,7 +60,7 @@ QByteArray BeamSteeringCWSourceSettings::serialize() const
    return s.final();
 }

-bool BeamSteeringCWSourceSettings::deserialize(const QByteArray& data)
+bool BeamSteeringCWModSettings::deserialize(const QByteArray& data)
 {
    SimpleDeserializer d(data);

@@ -15,15 +15,15 @@
 // along with this program. If not, see <http://www.gnu.org/licenses/>.          //
 ///////////////////////////////////////////////////////////////////////////////////

-#ifndef INCLUDE_BEAMSTEERINGCWSOURCESETTINGS_H_
-#define INCLUDE_BEAMSTEERINGCWSOURCESETTINGS_H_
+#ifndef INCLUDE_BEAMSTEERINGCWMODSETTINGS_H_
+#define INCLUDE_BEAMSTEERINGCWMODSETTINGS_H_

 #include <QByteArray>
 #include <QString>

 class Serializable;

-struct BeamSteeringCWSourceSettings
+struct BeamSteeringCWModSettings
 {
    int m_steerDegrees;
    quint32 m_rgbColor;
@@ -38,11 +38,11 @@ struct BeamSteeringCWSourceSettings

    Serializable *m_channelMarker;

-    BeamSteeringCWSourceSettings();
+    BeamSteeringCWModSettings();
    void resetToDefaults();
    void setChannelMarker(Serializable *channelMarker) { m_channelMarker = channelMarker; }
    QByteArray serialize() const;
    bool deserialize(const QByteArray& data);
 };

-#endif /* INCLUDE_BEAMSTEERINGCWSOURCESETTINGS_H_ */
+#endif /* INCLUDE_BEAMSTEERINGCWMODSETTINGS_H_ */
@@ -18,16 +18,16 @@
 #include <QMutexLocker>
 #include <QDebug>

-#include "dsp/upchannelizer.h"
+#include "dsp/upsamplechannelizer.h"
 #include "dsp/dspcommands.h"

-#include "beamsteeringcwsourceworker.h"
+#include "beamsteeringcwmodsource.h"


-MESSAGE_CLASS_DEFINITION(BeamSteeringCWSourceWorker::MsgConfigureChannelizer, Message)
-MESSAGE_CLASS_DEFINITION(BeamSteeringCWSourceWorker::MsgSignalNotification, Message)
+MESSAGE_CLASS_DEFINITION(BeamSteeringCWModSource::MsgConfigureChannelizer, Message)
+MESSAGE_CLASS_DEFINITION(BeamSteeringCWModSource::MsgSignalNotification, Message)

-BeamSteeringCWSourceWorker::BeamSteeringCWSourceWorker() :
+BeamSteeringCWModSource::BeamSteeringCWModSource() :
    m_mutex(QMutex::Recursive)
 {
    m_sampleMOFifo.init(2, 96000 * 8);
@@ -43,7 +43,7 @@ BeamSteeringCWSourceWorker::BeamSteeringCWSourceWorker() :
        &m_sampleMOFifo,
        &SampleMOFifo::dataSyncRead,
        this,
-        &BeamSteeringCWSourceWorker::handleData,
+        &BeamSteeringCWModSource::handleData,
        Qt::QueuedConnection
    );

@@ -51,7 +51,7 @@ BeamSteeringCWSourceWorker::BeamSteeringCWSourceWorker() :
    m_lastStream = 0;
 }

-BeamSteeringCWSourceWorker::~BeamSteeringCWSourceWorker()
+BeamSteeringCWModSource::~BeamSteeringCWModSource()
 {
    for (int i = 0; i < 2; i++)
    {
@@ -59,7 +59,7 @@ BeamSteeringCWSourceWorker::~BeamSteeringCWSourceWorker()
    }
 }

-void BeamSteeringCWSourceWorker::reset()
+void BeamSteeringCWModSource::reset()
 {
    QMutexLocker mutexLocker(&m_mutex);
    m_sampleMOFifo.reset();
@@ -69,14 +69,14 @@ void BeamSteeringCWSourceWorker::reset()
    }
 }

-void BeamSteeringCWSourceWorker::pull(const SampleVector::const_iterator& begin, unsigned int nbSamples, unsigned int streamIndex)
+void BeamSteeringCWModSource::pull(const SampleVector::const_iterator& begin, unsigned int nbSamples, unsigned int streamIndex)
 {
    if (streamIndex > 1) {
        return;
    }

    if (streamIndex == m_lastStream) {
-        qWarning("BeamSteeringCWSourceWorker::pull: twice same stream in a row: %u", streamIndex);
+        qWarning("BeamSteeringCWModSource::pull: twice same stream in a row: %u", streamIndex);
    }

    m_lastStream = streamIndex;
@@ -87,7 +87,7 @@ void BeamSteeringCWSourceWorker::pull(const SampleVector::const_iterator& begin,
    {
        if (m_sizes[0] != m_sizes[1])
        {
-            qWarning("BeamSteeringCWSourceWorker::pull: unequal sizes: [0]: %d [1]: %d", m_sizes[0], m_sizes[1]);
+            qWarning("BeamSteeringCWModSource::pull: unequal sizes: [0]: %d [1]: %d", m_sizes[0], m_sizes[1]);
            m_sampleMOFifo.writeSync(m_vbegin, std::min(m_sizes[0], m_sizes[1]));
        }
        else
@@ -97,7 +97,7 @@ void BeamSteeringCWSourceWorker::pull(const SampleVector::const_iterator& begin,
    }
 }

-void BeamSteeringCWSourceWorker::handleData()
+void BeamSteeringCWModSource::handleData()
 {
    QMutexLocker mutexLocker(&m_mutex);

@@ -126,7 +126,7 @@ void BeamSteeringCWSourceWorker::handleData()
    }
 }

-void BeamSteeringCWSourceWorker::processFifo(const std::vector<SampleVector>& data, unsigned int ibegin, unsigned int iend)
+void BeamSteeringCWModSource::processFifo(const std::vector<SampleVector>& data, unsigned int ibegin, unsigned int iend)
 {
    for (unsigned int stream = 0; stream < 2; stream++) {
        //TODO: m_channelizers[stream]->pull(data[stream].begin() + ibegin, iend - ibegin);
@@ -135,14 +135,14 @@ void BeamSteeringCWSourceWorker::processFifo(const std::vector<SampleVector>& da
    run();
 }

-void BeamSteeringCWSourceWorker::run()
+void BeamSteeringCWModSource::run()
 {
    // TODO
 }

-void BeamSteeringCWSourceWorker::handleInputMessages()
+void BeamSteeringCWModSource::handleInputMessages()
 {
-    qDebug("BeamSteeringCWSourceWorker::handleInputMessage");
+    qDebug("BeamSteeringCWModSource::handleInputMessage");
 	Message* message;

 	while ((message = m_inputMessageQueue.pop()) != 0)
@@ -153,7 +153,7 @@ void BeamSteeringCWSourceWorker::handleInputMessages()
 	}
 }

-bool BeamSteeringCWSourceWorker::handleMessage(const Message& cmd)
+bool BeamSteeringCWModSource::handleMessage(const Message& cmd)
 {
    if (MsgConfigureChannelizer::match(cmd))
    {
@@ -162,16 +162,17 @@ bool BeamSteeringCWSourceWorker::handleMessage(const Message& cmd)
        int log2Interp = cfg.getLog2Interp();
        int filterChainHash = cfg.getFilterChainHash();

-        qDebug() << "BeamSteeringCWSourceWorker::handleMessage: MsgConfigureChannelizer:"
+        qDebug() << "BeamSteeringCWModSource::handleMessage: MsgConfigureChannelizer:"
                << " log2Interp: " << log2Interp
                << " filterChainHash: " << filterChainHash;

        for (int i = 0; i < 2; i++)
        {
-            m_channelizers[i]->set(m_channelizers[i]->getInputMessageQueue(),
-                log2Interp,
-                filterChainHash);
-            //TODO: m_sinks[i].reset();
+            // TODO
+            // m_channelizers[i]->set(m_channelizers[i]->getInputMessageQueue(),
+            //     log2Interp,
+            //     filterChainHash);
+            // m_sinks[i].reset();
        }

        return true;
@@ -183,7 +184,7 @@ bool BeamSteeringCWSourceWorker::handleMessage(const Message& cmd)
        qint64 centerFrequency = cfg.getCenterFrequency();
        int streamIndex = cfg.getStreamIndex();

-        qDebug() << "BeamSteeringCWSourceWorker::handleMessage: MsgSignalNotification:"
+        qDebug() << "BeamSteeringCWModSource::handleMessage: MsgSignalNotification:"
                << " outputSampleRate: " << outputSampleRate
                << " centerFrequency: " << centerFrequency
                << " streamIndex: " << streamIndex;
@@ -191,14 +192,14 @@ bool BeamSteeringCWSourceWorker::handleMessage(const Message& cmd)
        if (streamIndex < 2)
        {
            DSPSignalNotification *notif = new DSPSignalNotification(outputSampleRate, centerFrequency);
-            m_channelizers[streamIndex]->getInputMessageQueue()->push(notif);
+            // TODO: m_channelizers[streamIndex]->getInputMessageQueue()->push(notif);
        }

        return true;
    }
    else
    {
-        qDebug("BeamSteeringCWSourceWorker::handleMessage: unhandled: %s", cmd.getIdentifier());
+        qDebug("BeamSteeringCWModSource::handleMessage: unhandled: %s", cmd.getIdentifier());
        return false;
    }
 }
@@ -15,8 +15,8 @@
 // along with this program. If not, see <http://www.gnu.org/licenses/>.          //
 ///////////////////////////////////////////////////////////////////////////////////

-#ifndef INCLUDE_BEAMSTEERINGCWSOURCEWORKER_H
-#define INCLUDE_BEAMSTEERINGCWSOURCEWORKER_H
+#ifndef INCLUDE_BEAMSTEERINGCWMODSOURCE_H
+#define INCLUDE_BEAMSTEERINGCWMODSOURCE_H

 #include <QObject>
 #include <QMutex>
@@ -25,10 +25,9 @@
 #include "util/message.h"
 #include "util/messagequeue.h"

-class UpChannelizer;
-class BasebandSampleSource;
+class UpSampleChannelizer;

-class BeamSteeringCWSourceWorker : public QObject
+class BeamSteeringCWModSource : public QObject
 {
    Q_OBJECT
 public:
@@ -78,8 +77,8 @@ public:
        { }
    };

-    BeamSteeringCWSourceWorker();
-    ~BeamSteeringCWSourceWorker();
+    BeamSteeringCWModSource();
+    ~BeamSteeringCWModSource();
    void reset();

    MessageQueue *getInputMessageQueue() { return &m_inputMessageQueue; } //!< Get the queue for asynchronous inbound communication
@@ -96,7 +95,7 @@ private:
    SampleMOFifo m_sampleMOFifo;
    std::vector<SampleVector::const_iterator> m_vbegin;
    int m_sizes[2];
-    UpChannelizer *m_channelizers[2];
+    UpSampleChannelizer *m_channelizers[2];
 	MessageQueue m_inputMessageQueue; //!< Queue for asynchronous inbound communication
    QMutex m_mutex;
    unsigned int m_lastStream;
@@ -107,4 +106,4 @@ private slots:
 };


-#endif // INCLUDE_BEAMSTEERINGCWSOURCEWORKER_H
+#endif // INCLUDE_BEAMSTEERINGCWMODSOURCE_H
@@ -16,35 +16,35 @@
 ///////////////////////////////////////////////////////////////////////////////////

 #include "SWGChannelSettings.h"
-#include "beamsteeringcwsource.h"
-#include "beamsteeringcwsourcewebapiadapter.h"
+#include "beamsteeringcwmod.h"
+#include "beamsteeringcwmodwebapiadapter.h"

-BeamSteeringCWSourceWebAPIAdapter::BeamSteeringCWSourceWebAPIAdapter()
+BeamSteeringCWModWebAPIAdapter::BeamSteeringCWModWebAPIAdapter()
 {}

-BeamSteeringCWSourceWebAPIAdapter::~BeamSteeringCWSourceWebAPIAdapter()
+BeamSteeringCWModWebAPIAdapter::~BeamSteeringCWModWebAPIAdapter()
 {}

-int BeamSteeringCWSourceWebAPIAdapter::webapiSettingsGet(
+int BeamSteeringCWModWebAPIAdapter::webapiSettingsGet(
        SWGSDRangel::SWGChannelSettings& response,
        QString& errorMessage)
 {
    (void) errorMessage;
-    response.setBeamSteeringCwSourceSettings(new SWGSDRangel::SWGBeamSteeringCWSourceSettings());
-    response.getBeamSteeringCwSourceSettings()->init();
-    BeamSteeringCWSource::webapiFormatChannelSettings(response, m_settings);
+    response.setBeamSteeringCwModSettings(new SWGSDRangel::SWGBeamSteeringCWModSettings());
+    response.getBeamSteeringCwModSettings()->init();
+    BeamSteeringCWMod::webapiFormatChannelSettings(response, m_settings);

    return 200;
 }

-int BeamSteeringCWSourceWebAPIAdapter::webapiSettingsPutPatch(
+int BeamSteeringCWModWebAPIAdapter::webapiSettingsPutPatch(
        bool force,
        const QStringList& channelSettingsKeys,
        SWGSDRangel::SWGChannelSettings& response,
        QString& errorMessage)
 {
    (void) errorMessage;
-    BeamSteeringCWSource::webapiUpdateChannelSettings(m_settings, channelSettingsKeys, response);
+    BeamSteeringCWMod::webapiUpdateChannelSettings(m_settings, channelSettingsKeys, response);

    return 200;
 }
@@ -15,19 +15,19 @@
 // along with this program. If not, see <http://www.gnu.org/licenses/>.          //
 ///////////////////////////////////////////////////////////////////////////////////

-#ifndef INCLUDE_BEAMSTEERINGCWSOURCE_WEBAPIADAPTER_H
-#define INCLUDE_BEAMSTEERINGCWSOURCE_WEBAPIADAPTER_H
+#ifndef INCLUDE_BEAMSTEERINGCWMO_WEBAPIADAPTER_H
+#define INCLUDE_BEAMSTEERINGCWMO_WEBAPIADAPTER_H

 #include "channel/channelwebapiadapter.h"
-#include "beamsteeringcwsourcesettings.h"
+#include "beamsteeringcwmodsettings.h"

 /**
 * Standalone API adapter only for the settings
 */
-class BeamSteeringCWSourceWebAPIAdapter : public ChannelWebAPIAdapter {
+class BeamSteeringCWModWebAPIAdapter : public ChannelWebAPIAdapter {
 public:
-    BeamSteeringCWSourceWebAPIAdapter();
-    virtual ~BeamSteeringCWSourceWebAPIAdapter();
+    BeamSteeringCWModWebAPIAdapter();
+    virtual ~BeamSteeringCWModWebAPIAdapter();

    virtual QByteArray serialize() const { return m_settings.serialize(); }
    virtual bool deserialize(const QByteArray& data) { return m_settings.deserialize(data); }
@@ -43,7 +43,7 @@ public:
            QString& errorMessage);

 private:
-    BeamSteeringCWSourceSettings m_settings;
+    BeamSteeringCWModSettings m_settings;
 };

-#endif // INCLUDE_BEAMSTEERINGCWSOURCE_WEBAPIADAPTER_H
+#endif // INCLUDE_BEAMSTEERINGCWMO_WEBAPIADAPTER_H
@@ -1,58 +0,0 @@
-project(beamsteeringcwsource)
-
-set(beamsteeringcwsource_SOURCES
-    beamsteeringcwsourceplugin.cpp
-    beamsteeringcwsource.cpp
-    beamsteeringcwsourcesettings.cpp
-    beamsteeringcwsourceworker.cpp
-    beamsteeringcwsourcewebapiadapter.cpp
-)
-
-set(beamsteeringcwsource_HEADERS
-    beamsteeringcwsourceplugin.h
-    beamsteeringcwsource.h
-    beamsteeringcwsourcesettings.h
-    beamsteeringcwsourceworker.h
-    beamsteeringcwsourcewebapiadapter.h
-)
-
-include_directories(
-    ${CMAKE_SOURCE_DIR}/swagger/sdrangel/code/qt5/client
-    ${Boost_INCLUDE_DIR}
-)
-
-if (NOT SERVER_MODE)
-    set(beamsteeringcwsource_SOURCES
-        ${beamsteeringcwsource_SOURCES}
-        beamsteeringcwsourcegui.cpp
-        beamsteeringcwsourcegui.ui
-    )
-    set(beamsteeringcwsource_HEADERS
-        ${beamsteeringcwsource_HEADERS}
-        beamsteeringcwsourcegui.h
-    )
-
-    set(TARGET_NAME beamsteeringcwsource)
-    set(TARGET_LIB "Qt5::Widgets")
-    set(TARGET_LIB_GUI "sdrgui")
-    set(INSTALL_FOLDER ${INSTALL_PLUGINS_DIR})
-else()
-    set(TARGET_NAME beamsteeringcwsourcesrv)
-    set(TARGET_LIB "")
-    set(TARGET_LIB_GUI "")
-    set(INSTALL_FOLDER ${INSTALL_PLUGINSSRV_DIR})
-endif()
-
-add_library(${TARGET_NAME} SHARED
-    ${beamsteeringcwsource_SOURCES}
-)
-
-target_link_libraries(${TARGET_NAME}
-    Qt5::Core
-    ${TARGET_LIB}
-	sdrbase
-	${TARGET_LIB_GUI}
-    swagger
-)
-
-install(TARGETS ${TARGET_NAME} DESTINATION ${INSTALL_FOLDER})
@@ -1,5 +1,5 @@
-BeamSteeringCWSourceSettings:
-  description: BeamSteeringCWSource
+BeamSteeringCWModSettings:
+  description: BeamSteeringCWMod
  properties:
    steerDegrees:
      type: integer
@@ -25,8 +25,8 @@ ChannelSettings:
      $ref: "/doc/swagger/include/ATVDemod.yaml#/ATVDemodSettings"
    ATVModSettings:
      $ref: "/doc/swagger/include/ATVMod.yaml#/ATVModSettings"
-    BeamSteeringCWSourceSettings:
-      $ref: "/doc/swagger/include/BeamSteeringCWSource.yaml#/BeamSteeringCWSourceSettings"
+    BeamSteeringCWModSettings:
+      $ref: "/doc/swagger/include/BeamSteeringCWMod.yaml#/BeamSteeringCWModSettings"
    BFMDemodSettings:
      $ref: "/doc/swagger/include/BFMDemod.yaml#/BFMDemodSettings"
    ChannelAnalyzerSettings:
@@ -0,0 +1,24 @@
+BeamSteeringCWModSettings:
+  description: BeamSteeringCWMod
+  properties:
+    steerDegrees:
+      type: integer
+    rgbColor:
+      type: integer
+    title:
+      type: string
+    log2Interp:
+      type: integer
+    filterChainHash:
+      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
@@ -25,8 +25,8 @@ ChannelSettings:
      $ref: "http://localhost:8081/api/swagger/include/ATVDemod.yaml#/ATVDemodSettings"
    ATVModSettings:
      $ref: "http://localhost:8081/api/swagger/include/ATVMod.yaml#/ATVModSettings"
-    BeamSteeringCWSourceSettings:
-      $ref: "http://localhost:8081/api/swagger/include/BeamSteeringCWSource.yaml#/BeamSteeringCWSourceSettings"
+    BeamSteeringCWModSettings:
+      $ref: "http://localhost:8081/api/swagger/include/BeamSteeringCWMod.yaml#/BeamSteeringCWModSettings"
    BFMDemodSettings:
      $ref: "http://localhost:8081/api/swagger/include/BFMDemod.yaml#/BFMDemodSettings"
    ChannelAnalyzerSettings:
@@ -0,0 +1,319 @@
+/**
+ * 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: 4.11.6
+ * 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 "SWGBeamSteeringCWModSettings.h"
+
+#include "SWGHelpers.h"
+
+#include <QJsonDocument>
+#include <QJsonArray>
+#include <QObject>
+#include <QDebug>
+
+namespace SWGSDRangel {
+
+SWGBeamSteeringCWModSettings::SWGBeamSteeringCWModSettings(QString* json) {
+    init();
+    this->fromJson(*json);
+}
+
+SWGBeamSteeringCWModSettings::SWGBeamSteeringCWModSettings() {
+    steer_degrees = 0;
+    m_steer_degrees_isSet = false;
+    rgb_color = 0;
+    m_rgb_color_isSet = false;
+    title = nullptr;
+    m_title_isSet = false;
+    log2_interp = 0;
+    m_log2_interp_isSet = false;
+    filter_chain_hash = 0;
+    m_filter_chain_hash_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;
+}
+
+SWGBeamSteeringCWModSettings::~SWGBeamSteeringCWModSettings() {
+    this->cleanup();
+}
+
+void
+SWGBeamSteeringCWModSettings::init() {
+    steer_degrees = 0;
+    m_steer_degrees_isSet = false;
+    rgb_color = 0;
+    m_rgb_color_isSet = false;
+    title = new QString("");
+    m_title_isSet = false;
+    log2_interp = 0;
+    m_log2_interp_isSet = false;
+    filter_chain_hash = 0;
+    m_filter_chain_hash_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;
+}
+
+void
+SWGBeamSteeringCWModSettings::cleanup() {
+
+
+    if(title != nullptr) { 
+        delete title;
+    }
+
+
+
+    if(reverse_api_address != nullptr) { 
+        delete reverse_api_address;
+    }
+
+
+
+}
+
+SWGBeamSteeringCWModSettings*
+SWGBeamSteeringCWModSettings::fromJson(QString &json) {
+    QByteArray array (json.toStdString().c_str());
+    QJsonDocument doc = QJsonDocument::fromJson(array);
+    QJsonObject jsonObject = doc.object();
+    this->fromJsonObject(jsonObject);
+    return this;
+}
+
+void
+SWGBeamSteeringCWModSettings::fromJsonObject(QJsonObject &pJson) {
+    ::SWGSDRangel::setValue(&steer_degrees, pJson["steerDegrees"], "qint32", "");
+    
+    ::SWGSDRangel::setValue(&rgb_color, pJson["rgbColor"], "qint32", "");
+    
+    ::SWGSDRangel::setValue(&title, pJson["title"], "QString", "QString");
+    
+    ::SWGSDRangel::setValue(&log2_interp, pJson["log2Interp"], "qint32", "");
+    
+    ::SWGSDRangel::setValue(&filter_chain_hash, pJson["filterChainHash"], "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", "");
+    
+}
+
+QString
+SWGBeamSteeringCWModSettings::asJson ()
+{
+    QJsonObject* obj = this->asJsonObject();
+
+    QJsonDocument doc(*obj);
+    QByteArray bytes = doc.toJson();
+    delete obj;
+    return QString(bytes);
+}
+
+QJsonObject*
+SWGBeamSteeringCWModSettings::asJsonObject() {
+    QJsonObject* obj = new QJsonObject();
+    if(m_steer_degrees_isSet){
+        obj->insert("steerDegrees", QJsonValue(steer_degrees));
+    }
+    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_log2_interp_isSet){
+        obj->insert("log2Interp", QJsonValue(log2_interp));
+    }
+    if(m_filter_chain_hash_isSet){
+        obj->insert("filterChainHash", QJsonValue(filter_chain_hash));
+    }
+    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));
+    }
+
+    return obj;
+}
+
+qint32
+SWGBeamSteeringCWModSettings::getSteerDegrees() {
+    return steer_degrees;
+}
+void
+SWGBeamSteeringCWModSettings::setSteerDegrees(qint32 steer_degrees) {
+    this->steer_degrees = steer_degrees;
+    this->m_steer_degrees_isSet = true;
+}
+
+qint32
+SWGBeamSteeringCWModSettings::getRgbColor() {
+    return rgb_color;
+}
+void
+SWGBeamSteeringCWModSettings::setRgbColor(qint32 rgb_color) {
+    this->rgb_color = rgb_color;
+    this->m_rgb_color_isSet = true;
+}
+
+QString*
+SWGBeamSteeringCWModSettings::getTitle() {
+    return title;
+}
+void
+SWGBeamSteeringCWModSettings::setTitle(QString* title) {
+    this->title = title;
+    this->m_title_isSet = true;
+}
+
+qint32
+SWGBeamSteeringCWModSettings::getLog2Interp() {
+    return log2_interp;
+}
+void
+SWGBeamSteeringCWModSettings::setLog2Interp(qint32 log2_interp) {
+    this->log2_interp = log2_interp;
+    this->m_log2_interp_isSet = true;
+}
+
+qint32
+SWGBeamSteeringCWModSettings::getFilterChainHash() {
+    return filter_chain_hash;
+}
+void
+SWGBeamSteeringCWModSettings::setFilterChainHash(qint32 filter_chain_hash) {
+    this->filter_chain_hash = filter_chain_hash;
+    this->m_filter_chain_hash_isSet = true;
+}
+
+qint32
+SWGBeamSteeringCWModSettings::getUseReverseApi() {
+    return use_reverse_api;
+}
+void
+SWGBeamSteeringCWModSettings::setUseReverseApi(qint32 use_reverse_api) {
+    this->use_reverse_api = use_reverse_api;
+    this->m_use_reverse_api_isSet = true;
+}
+
+QString*
+SWGBeamSteeringCWModSettings::getReverseApiAddress() {
+    return reverse_api_address;
+}
+void
+SWGBeamSteeringCWModSettings::setReverseApiAddress(QString* reverse_api_address) {
+    this->reverse_api_address = reverse_api_address;
+    this->m_reverse_api_address_isSet = true;
+}
+
+qint32
+SWGBeamSteeringCWModSettings::getReverseApiPort() {
+    return reverse_api_port;
+}
+void
+SWGBeamSteeringCWModSettings::setReverseApiPort(qint32 reverse_api_port) {
+    this->reverse_api_port = reverse_api_port;
+    this->m_reverse_api_port_isSet = true;
+}
+
+qint32
+SWGBeamSteeringCWModSettings::getReverseApiDeviceIndex() {
+    return reverse_api_device_index;
+}
+void
+SWGBeamSteeringCWModSettings::setReverseApiDeviceIndex(qint32 reverse_api_device_index) {
+    this->reverse_api_device_index = reverse_api_device_index;
+    this->m_reverse_api_device_index_isSet = true;
+}
+
+qint32
+SWGBeamSteeringCWModSettings::getReverseApiChannelIndex() {
+    return reverse_api_channel_index;
+}
+void
+SWGBeamSteeringCWModSettings::setReverseApiChannelIndex(qint32 reverse_api_channel_index) {
+    this->reverse_api_channel_index = reverse_api_channel_index;
+    this->m_reverse_api_channel_index_isSet = true;
+}
+
+
+bool
+SWGBeamSteeringCWModSettings::isSet(){
+    bool isObjectUpdated = false;
+    do{
+        if(m_steer_degrees_isSet){
+            isObjectUpdated = true; break;
+        }
+        if(m_rgb_color_isSet){
+            isObjectUpdated = true; break;
+        }
+        if(title && *title != QString("")){
+            isObjectUpdated = true; break;
+        }
+        if(m_log2_interp_isSet){
+            isObjectUpdated = true; break;
+        }
+        if(m_filter_chain_hash_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;
+        }
+    }while(false);
+    return isObjectUpdated;
+}
+}
+
@@ -0,0 +1,113 @@
+/**
+ * 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: 4.11.6
+ * 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.
+ */
+
+/*
+ * SWGBeamSteeringCWModSettings.h
+ *
+ * BeamSteeringCWMod
+ */
+
+#ifndef SWGBeamSteeringCWModSettings_H_
+#define SWGBeamSteeringCWModSettings_H_
+
+#include <QJsonObject>
+
+
+#include <QString>
+
+#include "SWGObject.h"
+#include "export.h"
+
+namespace SWGSDRangel {
+
+class SWG_API SWGBeamSteeringCWModSettings: public SWGObject {
+public:
+    SWGBeamSteeringCWModSettings();
+    SWGBeamSteeringCWModSettings(QString* json);
+    virtual ~SWGBeamSteeringCWModSettings();
+    void init();
+    void cleanup();
+
+    virtual QString asJson () override;
+    virtual QJsonObject* asJsonObject() override;
+    virtual void fromJsonObject(QJsonObject &json) override;
+    virtual SWGBeamSteeringCWModSettings* fromJson(QString &jsonString) override;
+
+    qint32 getSteerDegrees();
+    void setSteerDegrees(qint32 steer_degrees);
+
+    qint32 getRgbColor();
+    void setRgbColor(qint32 rgb_color);
+
+    QString* getTitle();
+    void setTitle(QString* title);
+
+    qint32 getLog2Interp();
+    void setLog2Interp(qint32 log2_interp);
+
+    qint32 getFilterChainHash();
+    void setFilterChainHash(qint32 filter_chain_hash);
+
+    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);
+
+
+    virtual bool isSet() override;
+
+private:
+    qint32 steer_degrees;
+    bool m_steer_degrees_isSet;
+
+    qint32 rgb_color;
+    bool m_rgb_color_isSet;
+
+    QString* title;
+    bool m_title_isSet;
+
+    qint32 log2_interp;
+    bool m_log2_interp_isSet;
+
+    qint32 filter_chain_hash;
+    bool m_filter_chain_hash_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;
+
+};
+
+}
+
+#endif /* SWGBeamSteeringCWModSettings_H_ */
@@ -44,8 +44,8 @@ SWGChannelSettings::SWGChannelSettings() {
    m_atv_demod_settings_isSet = false;
    atv_mod_settings = nullptr;
    m_atv_mod_settings_isSet = false;
-    beam_steering_cw_source_settings = nullptr;
-    m_beam_steering_cw_source_settings_isSet = false;
+    beam_steering_cw_mod_settings = nullptr;
+    m_beam_steering_cw_mod_settings_isSet = false;
    bfm_demod_settings = nullptr;
    m_bfm_demod_settings_isSet = false;
    channel_analyzer_settings = nullptr;
@@ -112,8 +112,8 @@ SWGChannelSettings::init() {
    m_atv_demod_settings_isSet = false;
    atv_mod_settings = new SWGATVModSettings();
    m_atv_mod_settings_isSet = false;
-    beam_steering_cw_source_settings = new SWGBeamSteeringCWSourceSettings();
-    m_beam_steering_cw_source_settings_isSet = false;
+    beam_steering_cw_mod_settings = new SWGBeamSteeringCWModSettings();
+    m_beam_steering_cw_mod_settings_isSet = false;
    bfm_demod_settings = new SWGBFMDemodSettings();
    m_bfm_demod_settings_isSet = false;
    channel_analyzer_settings = new SWGChannelAnalyzerSettings();
@@ -178,8 +178,8 @@ SWGChannelSettings::cleanup() {
    if(atv_mod_settings != nullptr) { 
        delete atv_mod_settings;
    }
-    if(beam_steering_cw_source_settings != nullptr) { 
-        delete beam_steering_cw_source_settings;
+    if(beam_steering_cw_mod_settings != nullptr) { 
+        delete beam_steering_cw_mod_settings;
    }
    if(bfm_demod_settings != nullptr) { 
        delete bfm_demod_settings;
@@ -273,7 +273,7 @@ SWGChannelSettings::fromJsonObject(QJsonObject &pJson) {
    
    ::SWGSDRangel::setValue(&atv_mod_settings, pJson["ATVModSettings"], "SWGATVModSettings", "SWGATVModSettings");
    
-    ::SWGSDRangel::setValue(&beam_steering_cw_source_settings, pJson["BeamSteeringCWSourceSettings"], "SWGBeamSteeringCWSourceSettings", "SWGBeamSteeringCWSourceSettings");
+    ::SWGSDRangel::setValue(&beam_steering_cw_mod_settings, pJson["BeamSteeringCWModSettings"], "SWGBeamSteeringCWModSettings", "SWGBeamSteeringCWModSettings");
    
    ::SWGSDRangel::setValue(&bfm_demod_settings, pJson["BFMDemodSettings"], "SWGBFMDemodSettings", "SWGBFMDemodSettings");
    
@@ -357,8 +357,8 @@ SWGChannelSettings::asJsonObject() {
    if((atv_mod_settings != nullptr) && (atv_mod_settings->isSet())){
        toJsonValue(QString("ATVModSettings"), atv_mod_settings, obj, QString("SWGATVModSettings"));
    }
-    if((beam_steering_cw_source_settings != nullptr) && (beam_steering_cw_source_settings->isSet())){
-        toJsonValue(QString("BeamSteeringCWSourceSettings"), beam_steering_cw_source_settings, obj, QString("SWGBeamSteeringCWSourceSettings"));
+    if((beam_steering_cw_mod_settings != nullptr) && (beam_steering_cw_mod_settings->isSet())){
+        toJsonValue(QString("BeamSteeringCWModSettings"), beam_steering_cw_mod_settings, obj, QString("SWGBeamSteeringCWModSettings"));
    }
    if((bfm_demod_settings != nullptr) && (bfm_demod_settings->isSet())){
        toJsonValue(QString("BFMDemodSettings"), bfm_demod_settings, obj, QString("SWGBFMDemodSettings"));
@@ -507,14 +507,14 @@ SWGChannelSettings::setAtvModSettings(SWGATVModSettings* atv_mod_settings) {
    this->m_atv_mod_settings_isSet = true;
 }

-SWGBeamSteeringCWSourceSettings*
-SWGChannelSettings::getBeamSteeringCwSourceSettings() {
-    return beam_steering_cw_source_settings;
+SWGBeamSteeringCWModSettings*
+SWGChannelSettings::getBeamSteeringCwModSettings() {
+    return beam_steering_cw_mod_settings;
 }
 void
-SWGChannelSettings::setBeamSteeringCwSourceSettings(SWGBeamSteeringCWSourceSettings* beam_steering_cw_source_settings) {
-    this->beam_steering_cw_source_settings = beam_steering_cw_source_settings;
-    this->m_beam_steering_cw_source_settings_isSet = true;
+SWGChannelSettings::setBeamSteeringCwModSettings(SWGBeamSteeringCWModSettings* beam_steering_cw_mod_settings) {
+    this->beam_steering_cw_mod_settings = beam_steering_cw_mod_settings;
+    this->m_beam_steering_cw_mod_settings_isSet = true;
 }

 SWGBFMDemodSettings*
@@ -756,7 +756,7 @@ SWGChannelSettings::isSet(){
        if(atv_mod_settings && atv_mod_settings->isSet()){
            isObjectUpdated = true; break;
        }
-        if(beam_steering_cw_source_settings && beam_steering_cw_source_settings->isSet()){
+        if(beam_steering_cw_mod_settings && beam_steering_cw_mod_settings->isSet()){
            isObjectUpdated = true; break;
        }
        if(bfm_demod_settings && bfm_demod_settings->isSet()){
@@ -27,7 +27,7 @@
 #include "SWGATVDemodSettings.h"
 #include "SWGATVModSettings.h"
 #include "SWGBFMDemodSettings.h"
-#include "SWGBeamSteeringCWSourceSettings.h"
+#include "SWGBeamSteeringCWModSettings.h"
 #include "SWGChannelAnalyzerSettings.h"
 #include "SWGDATVDemodSettings.h"
 #include "SWGDSDDemodSettings.h"
@@ -92,8 +92,8 @@ public:
    SWGATVModSettings* getAtvModSettings();
    void setAtvModSettings(SWGATVModSettings* atv_mod_settings);

-    SWGBeamSteeringCWSourceSettings* getBeamSteeringCwSourceSettings();
-    void setBeamSteeringCwSourceSettings(SWGBeamSteeringCWSourceSettings* beam_steering_cw_source_settings);
+    SWGBeamSteeringCWModSettings* getBeamSteeringCwModSettings();
+    void setBeamSteeringCwModSettings(SWGBeamSteeringCWModSettings* beam_steering_cw_mod_settings);

    SWGBFMDemodSettings* getBfmDemodSettings();
    void setBfmDemodSettings(SWGBFMDemodSettings* bfm_demod_settings);
@@ -186,8 +186,8 @@ private:
    SWGATVModSettings* atv_mod_settings;
    bool m_atv_mod_settings_isSet;

-    SWGBeamSteeringCWSourceSettings* beam_steering_cw_source_settings;
-    bool m_beam_steering_cw_source_settings_isSet;
+    SWGBeamSteeringCWModSettings* beam_steering_cw_mod_settings;
+    bool m_beam_steering_cw_mod_settings_isSet;

    SWGBFMDemodSettings* bfm_demod_settings;
    bool m_bfm_demod_settings_isSet;
@@ -35,7 +35,7 @@
 #include "SWGBFMDemodReport.h"
 #include "SWGBFMDemodSettings.h"
 #include "SWGBandwidth.h"
-#include "SWGBeamSteeringCWSourceSettings.h"
+#include "SWGBeamSteeringCWModSettings.h"
 #include "SWGBladeRF1InputSettings.h"
 #include "SWGBladeRF1OutputSettings.h"
 #include "SWGBladeRF2InputReport.h"
@@ -236,8 +236,8 @@ namespace SWGSDRangel {
    if(QString("SWGBandwidth").compare(type) == 0) {
      return new SWGBandwidth();
    }
-    if(QString("SWGBeamSteeringCWSourceSettings").compare(type) == 0) {
-      return new SWGBeamSteeringCWSourceSettings();
+    if(QString("SWGBeamSteeringCWModSettings").compare(type) == 0) {
+      return new SWGBeamSteeringCWModSettings();
    }
    if(QString("SWGBladeRF1InputSettings").compare(type) == 0) {
      return new SWGBladeRF1InputSettings();