Web API: plugin settings for RTL-SDR and LimeSDR

swagger/sdrangel/api/swagger/include/LimeSdr.yaml

@@ -0,0 +1,72 @@
+LimeSdrInputSettings:
+  properties:  
+    centerFrequency:
+      type: integer
+      format: int64
+    devSampleRate:
+      type: integer
+    log2HardDecim:
+      type: integer
+    dcBlock:
+      type: integer
+    iqCorrection:
+      type: integer
+    log2SoftDecim:
+      type: integer
+    lpfBW:        
+      type: integer
+    lpfFIREnable: 
+      type: integer
+    lpfFIRBW:     
+      type: integer
+    gain:         
+      type: integer
+    ncoEnable:    
+      type: integer
+    ncoFrequency: 
+      type: integer
+    antennaPath:
+      type: integer
+    gainMode:     
+      type: integer
+    lnaGain:      
+      type: integer
+    tiaGain:      
+      type: integer
+    pgaGain:      
+      type: integer
+    extClock:     
+      type: integer
+    extClockFreq: 
+      type: integer
+      
+LimeSdrOutputSettings:
+  properties:  
+    centerFrequency:
+      type: integer
+      format: int64
+    devSampleRate:
+      type: integer
+    log2HardInterp:
+      type: integer
+    log2SoftInterp:
+      type: integer
+    lpfBW:        
+      type: integer
+    lpfFIREnable: 
+      type: integer
+    lpfFIRBW:     
+      type: integer
+    gain:         
+      type: integer
+    ncoEnable:    
+      type: integer
+    ncoFrequency: 
+      type: integer
+    antennaPath:
+      type: integer
+    extClock:     
+      type: integer
+    extClockFreq: 
+      type: integer
+            

swagger/sdrangel/api/swagger/include/RtlSdr.yaml

@@ -0,0 +1,31 @@
+RtlSdrSettings:
+  properties:
+    devSampleRate:
+      type: integer
+    lowSampleRate:
+      type: integer
+    centerFrequency:
+      type: integer
+      format: int64
+    gain:
+      type: integer
+    loPpmCorrection:
+      type: integer
+    log2Decim:
+      type: integer
+    fcPos:
+      type: integer
+    dcBlock:
+      type: integer
+    iqImbalance:
+      type: integer
+    agc:
+      type: integer
+    noModMode:
+      type: integer
+    transverterMode:
+      type: integer
+    transverterDeltaFrequency:
+      type: integer
+      format: int64      
+    

swagger/sdrangel/api/swagger/swagger.yaml

@@ -530,7 +530,28 @@ paths:
             $ref: "#/definitions/ErrorResponse"
         "501":
           description: Function not implemented
-        
+    get:
+      description: Get device settings
+      operationId: devicesetDeviceGet
+      tags:
+        - DeviceSet
+      parameters:
+        - in: path
+          name: deviceSetIndex
+          type: integer
+          required: true
+          description: Index of device set in the device set list
+      responses:
+        "200":
+          description: On success returns current settings values
+          schema:
+            $ref: "#/definitions/DeviceSettings"
+        "500":
+          description: Error
+          schema:
+            $ref: "#/definitions/ErrorResponse"
+        "501":
+          description: Function not implemented
   /swagger:
     x-swagger-pipe: swagger_raw
 # complex objects have schema definitions
@@ -915,3 +936,23 @@ definitions:
         type: integer
       preset:
         $ref: "#/definitions/PresetIdentifier"
+  DeviceSettings:
+    description: Base device settings
+    discriminator: deviceType
+    required:
+      - deviceType
+    properties:
+      deviceType:
+        type: string
+      data:
+        type: object
+  DeviceSettingsImpl:
+    description: dummy structure to handle all devices settings
+    properties:
+      rtlsdr:
+        $ref: "http://localhost:8081/RtlSdr.yaml#/RtlSdrSettings"
+      limesdrInput:
+        $ref: "http://localhost:8081/LimeSdr.yaml#/LimeSdrInputSettings"
+      limesdrOutput:
+        $ref: "http://localhost:8081/LimeSdr.yaml#/LimeSdrOutputSettings"
+      

swagger/sdrangel/code/qt5/client/SWGDeviceSetApi.cpp

@@ -28,6 +28,56 @@ SWGDeviceSetApi::SWGDeviceSetApi(QString host, QString basePath) {
     this->basePath = basePath;
 }
 
+void
+SWGDeviceSetApi::devicesetDeviceGet(qint32 device_set_index) {
+    QString fullPath;
+    fullPath.append(this->host).append(this->basePath).append("/sdrangel/deviceset/{deviceSetIndex}/device");
+
+    QString device_set_indexPathParam("{"); device_set_indexPathParam.append("deviceSetIndex").append("}");
+    fullPath.replace(device_set_indexPathParam, stringValue(device_set_index));
+
+
+    HttpRequestWorker *worker = new HttpRequestWorker();
+    HttpRequestInput input(fullPath, "GET");
+
+
+
+
+
+    foreach(QString key, this->defaultHeaders.keys()) {
+        input.headers.insert(key, this->defaultHeaders.value(key));
+    }
+
+    connect(worker,
+            &HttpRequestWorker::on_execution_finished,
+            this,
+            &SWGDeviceSetApi::devicesetDeviceGetCallback);
+
+    worker->execute(&input);
+}
+
+void
+SWGDeviceSetApi::devicesetDeviceGetCallback(HttpRequestWorker * worker) {
+    QString msg;
+    QString error_str = worker->error_str;
+    QNetworkReply::NetworkError error_type = worker->error_type;
+
+    if (worker->error_type == QNetworkReply::NoError) {
+        msg = QString("Success! %1 bytes").arg(worker->response.length());
+    }
+    else {
+        msg = "Error: " + worker->error_str;
+    }
+
+
+    QString json(worker->response);
+    SWGDeviceSettings* output = static_cast<SWGDeviceSettings*>(create(json, QString("SWGDeviceSettings")));
+    worker->deleteLater();
+
+    emit devicesetDeviceGetSignal(output);
+    emit devicesetDeviceGetSignalE(output, error_type, error_str);
+}
+
 void
 SWGDeviceSetApi::devicesetDevicePut(qint32 device_set_index, SWGDeviceListItem body) {
     QString fullPath;

swagger/sdrangel/code/qt5/client/SWGDeviceSetApi.h

@@ -17,6 +17,7 @@
 
 #include "SWGDeviceListItem.h"
 #include "SWGDeviceSet.h"
+#include "SWGDeviceSettings.h"
 #include "SWGErrorResponse.h"
 
 #include <QObject>
@@ -35,17 +36,21 @@ public:
     QString basePath;
     QMap<QString, QString> defaultHeaders;
 
+    void devicesetDeviceGet(qint32 device_set_index);
     void devicesetDevicePut(qint32 device_set_index, SWGDeviceListItem body);
     void devicesetGet(qint32 device_set_index);
     
 private:
+    void devicesetDeviceGetCallback (HttpRequestWorker * worker);
     void devicesetDevicePutCallback (HttpRequestWorker * worker);
     void devicesetGetCallback (HttpRequestWorker * worker);
     
 signals:
+    void devicesetDeviceGetSignal(SWGDeviceSettings* summary);
     void devicesetDevicePutSignal(SWGDeviceListItem* summary);
     void devicesetGetSignal(SWGDeviceSet* summary);
     
+    void devicesetDeviceGetSignalE(SWGDeviceSettings* summary, QNetworkReply::NetworkError error_type, QString& error_str);
     void devicesetDevicePutSignalE(SWGDeviceListItem* summary, QNetworkReply::NetworkError error_type, QString& error_str);
     void devicesetGetSignalE(SWGDeviceSet* summary, QNetworkReply::NetworkError error_type, QString& error_str);
     

swagger/sdrangel/code/qt5/client/SWGDeviceSettings.cpp

@@ -0,0 +1,112 @@
+/**
+ * SDRangel
+ * This is the web API of SDRangel SDR software. SDRangel is an Open Source Qt5/OpenGL 3.0+ GUI and server Software Defined Radio and signal analyzer in software. It supports Airspy, BladeRF, HackRF, LimeSDR, PlutoSDR, RTL-SDR, SDRplay RSP1 and FunCube
+ *
+ * OpenAPI spec version: 4.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 "SWGDeviceSettings.h"
+
+#include "SWGHelpers.h"
+
+#include <QJsonDocument>
+#include <QJsonArray>
+#include <QObject>
+#include <QDebug>
+
+namespace SWGSDRangel {
+
+SWGDeviceSettings::SWGDeviceSettings(QString* json) {
+    init();
+    this->fromJson(*json);
+}
+
+SWGDeviceSettings::SWGDeviceSettings() {
+    init();
+}
+
+SWGDeviceSettings::~SWGDeviceSettings() {
+    this->cleanup();
+}
+
+void
+SWGDeviceSettings::init() {
+    device_type = new QString("");
+    data = NULL;
+}
+
+void
+SWGDeviceSettings::cleanup() {
+    
+    if(device_type != nullptr) {
+        delete device_type;
+    }
+
+    if(data != nullptr) {
+        delete data;
+    }
+}
+
+SWGDeviceSettings*
+SWGDeviceSettings::fromJson(QString &json) {
+    QByteArray array (json.toStdString().c_str());
+    QJsonDocument doc = QJsonDocument::fromJson(array);
+    QJsonObject jsonObject = doc.object();
+    this->fromJsonObject(jsonObject);
+    return this;
+}
+
+void
+SWGDeviceSettings::fromJsonObject(QJsonObject &pJson) {
+    ::SWGSDRangel::setValue(&device_type, pJson["deviceType"], "QString", "QString");
+    ::SWGSDRangel::setValue(&data, pJson["data"], "SWGObject", "SWGObject");
+}
+
+QString
+SWGDeviceSettings::asJson ()
+{
+    QJsonObject* obj = this->asJsonObject();
+    
+    QJsonDocument doc(*obj);
+    QByteArray bytes = doc.toJson();
+    return QString(bytes);
+}
+
+QJsonObject*
+SWGDeviceSettings::asJsonObject() {
+    QJsonObject* obj = new QJsonObject();
+    
+    toJsonValue(QString("deviceType"), device_type, obj, QString("QString"));
+
+    toJsonValue(QString("data"), data, obj, QString("SWGObject"));
+
+    return obj;
+}
+
+QString*
+SWGDeviceSettings::getDeviceType() {
+    return device_type;
+}
+void
+SWGDeviceSettings::setDeviceType(QString* device_type) {
+    this->device_type = device_type;
+}
+
+SWGObject*
+SWGDeviceSettings::getData() {
+    return data;
+}
+void
+SWGDeviceSettings::setData(SWGObject* data) {
+    this->data = data;
+}
+
+
+}
+

swagger/sdrangel/code/qt5/client/SWGDeviceSettings.h

@@ -0,0 +1,60 @@
+/**
+ * SDRangel
+ * This is the web API of SDRangel SDR software. SDRangel is an Open Source Qt5/OpenGL 3.0+ GUI and server Software Defined Radio and signal analyzer in software. It supports Airspy, BladeRF, HackRF, LimeSDR, PlutoSDR, RTL-SDR, SDRplay RSP1 and FunCube
+ *
+ * OpenAPI spec version: 4.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.
+ */
+
+/*
+ * SWGDeviceSettings.h
+ * 
+ * Base device settings
+ */
+
+#ifndef SWGDeviceSettings_H_
+#define SWGDeviceSettings_H_
+
+#include <QJsonObject>
+
+
+#include "SWGObject.h"
+#include <QString>
+
+#include "SWGObject.h"
+
+
+namespace SWGSDRangel {
+
+class SWGDeviceSettings: public SWGObject {
+public:
+    SWGDeviceSettings();
+    SWGDeviceSettings(QString* json);
+    virtual ~SWGDeviceSettings();
+    void init();
+    void cleanup();
+
+    QString asJson ();
+    QJsonObject* asJsonObject();
+    void fromJsonObject(QJsonObject &json);
+    SWGDeviceSettings* fromJson(QString &jsonString);
+
+    QString* getDeviceType();
+    void setDeviceType(QString* device_type);
+
+    SWGObject* getData();
+    void setData(SWGObject* data);
+
+
+private:
+    QString* device_type;
+    SWGObject* data;
+};
+
+}
+
+#endif /* SWGDeviceSettings_H_ */

swagger/sdrangel/code/qt5/client/SWGDeviceSettingsImpl.cpp

@@ -0,0 +1,129 @@
+/**
+ * SDRangel
+ * This is the web API of SDRangel SDR software. SDRangel is an Open Source Qt5/OpenGL 3.0+ GUI and server Software Defined Radio and signal analyzer in software. It supports Airspy, BladeRF, HackRF, LimeSDR, PlutoSDR, RTL-SDR, SDRplay RSP1 and FunCube
+ *
+ * OpenAPI spec version: 4.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 "SWGDeviceSettingsImpl.h"
+
+#include "SWGHelpers.h"
+
+#include <QJsonDocument>
+#include <QJsonArray>
+#include <QObject>
+#include <QDebug>
+
+namespace SWGSDRangel {
+
+SWGDeviceSettingsImpl::SWGDeviceSettingsImpl(QString* json) {
+    init();
+    this->fromJson(*json);
+}
+
+SWGDeviceSettingsImpl::SWGDeviceSettingsImpl() {
+    init();
+}
+
+SWGDeviceSettingsImpl::~SWGDeviceSettingsImpl() {
+    this->cleanup();
+}
+
+void
+SWGDeviceSettingsImpl::init() {
+    rtlsdr = new SWGRtlSdrSettings();
+    limesdr_input = new SWGLimeSdrInputSettings();
+    limesdr_output = new SWGLimeSdrOutputSettings();
+}
+
+void
+SWGDeviceSettingsImpl::cleanup() {
+    
+    if(rtlsdr != nullptr) {
+        delete rtlsdr;
+    }
+
+    if(limesdr_input != nullptr) {
+        delete limesdr_input;
+    }
+
+    if(limesdr_output != nullptr) {
+        delete limesdr_output;
+    }
+}
+
+SWGDeviceSettingsImpl*
+SWGDeviceSettingsImpl::fromJson(QString &json) {
+    QByteArray array (json.toStdString().c_str());
+    QJsonDocument doc = QJsonDocument::fromJson(array);
+    QJsonObject jsonObject = doc.object();
+    this->fromJsonObject(jsonObject);
+    return this;
+}
+
+void
+SWGDeviceSettingsImpl::fromJsonObject(QJsonObject &pJson) {
+    ::SWGSDRangel::setValue(&rtlsdr, pJson["rtlsdr"], "SWGRtlSdrSettings", "SWGRtlSdrSettings");
+    ::SWGSDRangel::setValue(&limesdr_input, pJson["limesdrInput"], "SWGLimeSdrInputSettings", "SWGLimeSdrInputSettings");
+    ::SWGSDRangel::setValue(&limesdr_output, pJson["limesdrOutput"], "SWGLimeSdrOutputSettings", "SWGLimeSdrOutputSettings");
+}
+
+QString
+SWGDeviceSettingsImpl::asJson ()
+{
+    QJsonObject* obj = this->asJsonObject();
+    
+    QJsonDocument doc(*obj);
+    QByteArray bytes = doc.toJson();
+    return QString(bytes);
+}
+
+QJsonObject*
+SWGDeviceSettingsImpl::asJsonObject() {
+    QJsonObject* obj = new QJsonObject();
+    
+    toJsonValue(QString("rtlsdr"), rtlsdr, obj, QString("SWGRtlSdrSettings"));
+
+    toJsonValue(QString("limesdrInput"), limesdr_input, obj, QString("SWGLimeSdrInputSettings"));
+
+    toJsonValue(QString("limesdrOutput"), limesdr_output, obj, QString("SWGLimeSdrOutputSettings"));
+
+    return obj;
+}
+
+SWGRtlSdrSettings*
+SWGDeviceSettingsImpl::getRtlsdr() {
+    return rtlsdr;
+}
+void
+SWGDeviceSettingsImpl::setRtlsdr(SWGRtlSdrSettings* rtlsdr) {
+    this->rtlsdr = rtlsdr;
+}
+
+SWGLimeSdrInputSettings*
+SWGDeviceSettingsImpl::getLimesdrInput() {
+    return limesdr_input;
+}
+void
+SWGDeviceSettingsImpl::setLimesdrInput(SWGLimeSdrInputSettings* limesdr_input) {
+    this->limesdr_input = limesdr_input;
+}
+
+SWGLimeSdrOutputSettings*
+SWGDeviceSettingsImpl::getLimesdrOutput() {
+    return limesdr_output;
+}
+void
+SWGDeviceSettingsImpl::setLimesdrOutput(SWGLimeSdrOutputSettings* limesdr_output) {
+    this->limesdr_output = limesdr_output;
+}
+
+
+}
+

swagger/sdrangel/code/qt5/client/SWGDeviceSettingsImpl.h

@@ -0,0 +1,65 @@
+/**
+ * SDRangel
+ * This is the web API of SDRangel SDR software. SDRangel is an Open Source Qt5/OpenGL 3.0+ GUI and server Software Defined Radio and signal analyzer in software. It supports Airspy, BladeRF, HackRF, LimeSDR, PlutoSDR, RTL-SDR, SDRplay RSP1 and FunCube
+ *
+ * OpenAPI spec version: 4.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.
+ */
+
+/*
+ * SWGDeviceSettingsImpl.h
+ * 
+ * dummy structure to handle all devices settings
+ */
+
+#ifndef SWGDeviceSettingsImpl_H_
+#define SWGDeviceSettingsImpl_H_
+
+#include <QJsonObject>
+
+
+#include "SWGLimeSdrInputSettings.h"
+#include "SWGLimeSdrOutputSettings.h"
+#include "SWGRtlSdrSettings.h"
+
+#include "SWGObject.h"
+
+
+namespace SWGSDRangel {
+
+class SWGDeviceSettingsImpl: public SWGObject {
+public:
+    SWGDeviceSettingsImpl();
+    SWGDeviceSettingsImpl(QString* json);
+    virtual ~SWGDeviceSettingsImpl();
+    void init();
+    void cleanup();
+
+    QString asJson ();
+    QJsonObject* asJsonObject();
+    void fromJsonObject(QJsonObject &json);
+    SWGDeviceSettingsImpl* fromJson(QString &jsonString);
+
+    SWGRtlSdrSettings* getRtlsdr();
+    void setRtlsdr(SWGRtlSdrSettings* rtlsdr);
+
+    SWGLimeSdrInputSettings* getLimesdrInput();
+    void setLimesdrInput(SWGLimeSdrInputSettings* limesdr_input);
+
+    SWGLimeSdrOutputSettings* getLimesdrOutput();
+    void setLimesdrOutput(SWGLimeSdrOutputSettings* limesdr_output);
+
+
+private:
+    SWGRtlSdrSettings* rtlsdr;
+    SWGLimeSdrInputSettings* limesdr_input;
+    SWGLimeSdrOutputSettings* limesdr_output;
+};
+
+}
+
+#endif /* SWGDeviceSettingsImpl_H_ */

swagger/sdrangel/code/qt5/client/SWGLimeSdrInputSettings.cpp

@@ -0,0 +1,344 @@
+/**
+ * SDRangel
+ * This is the web API of SDRangel SDR software. SDRangel is an Open Source Qt5/OpenGL 3.0+ GUI and server Software Defined Radio and signal analyzer in software. It supports Airspy, BladeRF, HackRF, LimeSDR, PlutoSDR, RTL-SDR, SDRplay RSP1 and FunCube
+ *
+ * OpenAPI spec version: 4.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 "SWGLimeSdrInputSettings.h"
+
+#include "SWGHelpers.h"
+
+#include <QJsonDocument>
+#include <QJsonArray>
+#include <QObject>
+#include <QDebug>
+
+namespace SWGSDRangel {
+
+SWGLimeSdrInputSettings::SWGLimeSdrInputSettings(QString* json) {
+    init();
+    this->fromJson(*json);
+}
+
+SWGLimeSdrInputSettings::SWGLimeSdrInputSettings() {
+    init();
+}
+
+SWGLimeSdrInputSettings::~SWGLimeSdrInputSettings() {
+    this->cleanup();
+}
+
+void
+SWGLimeSdrInputSettings::init() {
+    center_frequency = 0L;
+    dev_sample_rate = 0;
+    log2_hard_decim = 0;
+    dc_block = 0;
+    iq_correction = 0;
+    log2_soft_decim = 0;
+    lpf_bw = 0;
+    lpf_fir_enable = 0;
+    lpf_firbw = 0;
+    gain = 0;
+    nco_enable = 0;
+    nco_frequency = 0;
+    antenna_path = 0;
+    gain_mode = 0;
+    lna_gain = 0;
+    tia_gain = 0;
+    pga_gain = 0;
+    ext_clock = 0;
+    ext_clock_freq = 0;
+}
+
+void
+SWGLimeSdrInputSettings::cleanup() {
+    
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+SWGLimeSdrInputSettings*
+SWGLimeSdrInputSettings::fromJson(QString &json) {
+    QByteArray array (json.toStdString().c_str());
+    QJsonDocument doc = QJsonDocument::fromJson(array);
+    QJsonObject jsonObject = doc.object();
+    this->fromJsonObject(jsonObject);
+    return this;
+}
+
+void
+SWGLimeSdrInputSettings::fromJsonObject(QJsonObject &pJson) {
+    ::SWGSDRangel::setValue(&center_frequency, pJson["centerFrequency"], "qint64", "");
+    ::SWGSDRangel::setValue(&dev_sample_rate, pJson["devSampleRate"], "qint32", "");
+    ::SWGSDRangel::setValue(&log2_hard_decim, pJson["log2HardDecim"], "qint32", "");
+    ::SWGSDRangel::setValue(&dc_block, pJson["dcBlock"], "qint32", "");
+    ::SWGSDRangel::setValue(&iq_correction, pJson["iqCorrection"], "qint32", "");
+    ::SWGSDRangel::setValue(&log2_soft_decim, pJson["log2SoftDecim"], "qint32", "");
+    ::SWGSDRangel::setValue(&lpf_bw, pJson["lpfBW"], "qint32", "");
+    ::SWGSDRangel::setValue(&lpf_fir_enable, pJson["lpfFIREnable"], "qint32", "");
+    ::SWGSDRangel::setValue(&lpf_firbw, pJson["lpfFIRBW"], "qint32", "");
+    ::SWGSDRangel::setValue(&gain, pJson["gain"], "qint32", "");
+    ::SWGSDRangel::setValue(&nco_enable, pJson["ncoEnable"], "qint32", "");
+    ::SWGSDRangel::setValue(&nco_frequency, pJson["ncoFrequency"], "qint32", "");
+    ::SWGSDRangel::setValue(&antenna_path, pJson["antennaPath"], "qint32", "");
+    ::SWGSDRangel::setValue(&gain_mode, pJson["gainMode"], "qint32", "");
+    ::SWGSDRangel::setValue(&lna_gain, pJson["lnaGain"], "qint32", "");
+    ::SWGSDRangel::setValue(&tia_gain, pJson["tiaGain"], "qint32", "");
+    ::SWGSDRangel::setValue(&pga_gain, pJson["pgaGain"], "qint32", "");
+    ::SWGSDRangel::setValue(&ext_clock, pJson["extClock"], "qint32", "");
+    ::SWGSDRangel::setValue(&ext_clock_freq, pJson["extClockFreq"], "qint32", "");
+}
+
+QString
+SWGLimeSdrInputSettings::asJson ()
+{
+    QJsonObject* obj = this->asJsonObject();
+    
+    QJsonDocument doc(*obj);
+    QByteArray bytes = doc.toJson();
+    return QString(bytes);
+}
+
+QJsonObject*
+SWGLimeSdrInputSettings::asJsonObject() {
+    QJsonObject* obj = new QJsonObject();
+    
+    obj->insert("centerFrequency", QJsonValue(center_frequency));
+
+    obj->insert("devSampleRate", QJsonValue(dev_sample_rate));
+
+    obj->insert("log2HardDecim", QJsonValue(log2_hard_decim));
+
+    obj->insert("dcBlock", QJsonValue(dc_block));
+
+    obj->insert("iqCorrection", QJsonValue(iq_correction));
+
+    obj->insert("log2SoftDecim", QJsonValue(log2_soft_decim));
+
+    obj->insert("lpfBW", QJsonValue(lpf_bw));
+
+    obj->insert("lpfFIREnable", QJsonValue(lpf_fir_enable));
+
+    obj->insert("lpfFIRBW", QJsonValue(lpf_firbw));
+
+    obj->insert("gain", QJsonValue(gain));
+
+    obj->insert("ncoEnable", QJsonValue(nco_enable));
+
+    obj->insert("ncoFrequency", QJsonValue(nco_frequency));
+
+    obj->insert("antennaPath", QJsonValue(antenna_path));
+
+    obj->insert("gainMode", QJsonValue(gain_mode));
+
+    obj->insert("lnaGain", QJsonValue(lna_gain));
+
+    obj->insert("tiaGain", QJsonValue(tia_gain));
+
+    obj->insert("pgaGain", QJsonValue(pga_gain));
+
+    obj->insert("extClock", QJsonValue(ext_clock));
+
+    obj->insert("extClockFreq", QJsonValue(ext_clock_freq));
+
+    return obj;
+}
+
+qint64
+SWGLimeSdrInputSettings::getCenterFrequency() {
+    return center_frequency;
+}
+void
+SWGLimeSdrInputSettings::setCenterFrequency(qint64 center_frequency) {
+    this->center_frequency = center_frequency;
+}
+
+qint32
+SWGLimeSdrInputSettings::getDevSampleRate() {
+    return dev_sample_rate;
+}
+void
+SWGLimeSdrInputSettings::setDevSampleRate(qint32 dev_sample_rate) {
+    this->dev_sample_rate = dev_sample_rate;
+}
+
+qint32
+SWGLimeSdrInputSettings::getLog2HardDecim() {
+    return log2_hard_decim;
+}
+void
+SWGLimeSdrInputSettings::setLog2HardDecim(qint32 log2_hard_decim) {
+    this->log2_hard_decim = log2_hard_decim;
+}
+
+qint32
+SWGLimeSdrInputSettings::getDcBlock() {
+    return dc_block;
+}
+void
+SWGLimeSdrInputSettings::setDcBlock(qint32 dc_block) {
+    this->dc_block = dc_block;
+}
+
+qint32
+SWGLimeSdrInputSettings::getIqCorrection() {
+    return iq_correction;
+}
+void
+SWGLimeSdrInputSettings::setIqCorrection(qint32 iq_correction) {
+    this->iq_correction = iq_correction;
+}
+
+qint32
+SWGLimeSdrInputSettings::getLog2SoftDecim() {
+    return log2_soft_decim;
+}
+void
+SWGLimeSdrInputSettings::setLog2SoftDecim(qint32 log2_soft_decim) {
+    this->log2_soft_decim = log2_soft_decim;
+}
+
+qint32
+SWGLimeSdrInputSettings::getLpfBw() {
+    return lpf_bw;
+}
+void
+SWGLimeSdrInputSettings::setLpfBw(qint32 lpf_bw) {
+    this->lpf_bw = lpf_bw;
+}
+
+qint32
+SWGLimeSdrInputSettings::getLpfFirEnable() {
+    return lpf_fir_enable;
+}
+void
+SWGLimeSdrInputSettings::setLpfFirEnable(qint32 lpf_fir_enable) {
+    this->lpf_fir_enable = lpf_fir_enable;
+}
+
+qint32
+SWGLimeSdrInputSettings::getLpfFirbw() {
+    return lpf_firbw;
+}
+void
+SWGLimeSdrInputSettings::setLpfFirbw(qint32 lpf_firbw) {
+    this->lpf_firbw = lpf_firbw;
+}
+
+qint32
+SWGLimeSdrInputSettings::getGain() {
+    return gain;
+}
+void
+SWGLimeSdrInputSettings::setGain(qint32 gain) {
+    this->gain = gain;
+}
+
+qint32
+SWGLimeSdrInputSettings::getNcoEnable() {
+    return nco_enable;
+}
+void
+SWGLimeSdrInputSettings::setNcoEnable(qint32 nco_enable) {
+    this->nco_enable = nco_enable;
+}
+
+qint32
+SWGLimeSdrInputSettings::getNcoFrequency() {
+    return nco_frequency;
+}
+void
+SWGLimeSdrInputSettings::setNcoFrequency(qint32 nco_frequency) {
+    this->nco_frequency = nco_frequency;
+}
+
+qint32
+SWGLimeSdrInputSettings::getAntennaPath() {
+    return antenna_path;
+}
+void
+SWGLimeSdrInputSettings::setAntennaPath(qint32 antenna_path) {
+    this->antenna_path = antenna_path;
+}
+
+qint32
+SWGLimeSdrInputSettings::getGainMode() {
+    return gain_mode;
+}
+void
+SWGLimeSdrInputSettings::setGainMode(qint32 gain_mode) {
+    this->gain_mode = gain_mode;
+}
+
+qint32
+SWGLimeSdrInputSettings::getLnaGain() {
+    return lna_gain;
+}
+void
+SWGLimeSdrInputSettings::setLnaGain(qint32 lna_gain) {
+    this->lna_gain = lna_gain;
+}
+
+qint32
+SWGLimeSdrInputSettings::getTiaGain() {
+    return tia_gain;
+}
+void
+SWGLimeSdrInputSettings::setTiaGain(qint32 tia_gain) {
+    this->tia_gain = tia_gain;
+}
+
+qint32
+SWGLimeSdrInputSettings::getPgaGain() {
+    return pga_gain;
+}
+void
+SWGLimeSdrInputSettings::setPgaGain(qint32 pga_gain) {
+    this->pga_gain = pga_gain;
+}
+
+qint32
+SWGLimeSdrInputSettings::getExtClock() {
+    return ext_clock;
+}
+void
+SWGLimeSdrInputSettings::setExtClock(qint32 ext_clock) {
+    this->ext_clock = ext_clock;
+}
+
+qint32
+SWGLimeSdrInputSettings::getExtClockFreq() {
+    return ext_clock_freq;
+}
+void
+SWGLimeSdrInputSettings::setExtClockFreq(qint32 ext_clock_freq) {
+    this->ext_clock_freq = ext_clock_freq;
+}
+
+
+}
+

swagger/sdrangel/code/qt5/client/SWGLimeSdrInputSettings.h

@@ -0,0 +1,126 @@
+/**
+ * SDRangel
+ * This is the web API of SDRangel SDR software. SDRangel is an Open Source Qt5/OpenGL 3.0+ GUI and server Software Defined Radio and signal analyzer in software. It supports Airspy, BladeRF, HackRF, LimeSDR, PlutoSDR, RTL-SDR, SDRplay RSP1 and FunCube
+ *
+ * OpenAPI spec version: 4.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.
+ */
+
+/*
+ * SWGLimeSdrInputSettings.h
+ * 
+ * 
+ */
+
+#ifndef SWGLimeSdrInputSettings_H_
+#define SWGLimeSdrInputSettings_H_
+
+#include <QJsonObject>
+
+
+
+#include "SWGObject.h"
+
+
+namespace SWGSDRangel {
+
+class SWGLimeSdrInputSettings: public SWGObject {
+public:
+    SWGLimeSdrInputSettings();
+    SWGLimeSdrInputSettings(QString* json);
+    virtual ~SWGLimeSdrInputSettings();
+    void init();
+    void cleanup();
+
+    QString asJson ();
+    QJsonObject* asJsonObject();
+    void fromJsonObject(QJsonObject &json);
+    SWGLimeSdrInputSettings* fromJson(QString &jsonString);
+
+    qint64 getCenterFrequency();
+    void setCenterFrequency(qint64 center_frequency);
+
+    qint32 getDevSampleRate();
+    void setDevSampleRate(qint32 dev_sample_rate);
+
+    qint32 getLog2HardDecim();
+    void setLog2HardDecim(qint32 log2_hard_decim);
+
+    qint32 getDcBlock();
+    void setDcBlock(qint32 dc_block);
+
+    qint32 getIqCorrection();
+    void setIqCorrection(qint32 iq_correction);
+
+    qint32 getLog2SoftDecim();
+    void setLog2SoftDecim(qint32 log2_soft_decim);
+
+    qint32 getLpfBw();
+    void setLpfBw(qint32 lpf_bw);
+
+    qint32 getLpfFirEnable();
+    void setLpfFirEnable(qint32 lpf_fir_enable);
+
+    qint32 getLpfFirbw();
+    void setLpfFirbw(qint32 lpf_firbw);
+
+    qint32 getGain();
+    void setGain(qint32 gain);
+
+    qint32 getNcoEnable();
+    void setNcoEnable(qint32 nco_enable);
+
+    qint32 getNcoFrequency();
+    void setNcoFrequency(qint32 nco_frequency);
+
+    qint32 getAntennaPath();
+    void setAntennaPath(qint32 antenna_path);
+
+    qint32 getGainMode();
+    void setGainMode(qint32 gain_mode);
+
+    qint32 getLnaGain();
+    void setLnaGain(qint32 lna_gain);
+
+    qint32 getTiaGain();
+    void setTiaGain(qint32 tia_gain);
+
+    qint32 getPgaGain();
+    void setPgaGain(qint32 pga_gain);
+
+    qint32 getExtClock();
+    void setExtClock(qint32 ext_clock);
+
+    qint32 getExtClockFreq();
+    void setExtClockFreq(qint32 ext_clock_freq);
+
+
+private:
+    qint64 center_frequency;
+    qint32 dev_sample_rate;
+    qint32 log2_hard_decim;
+    qint32 dc_block;
+    qint32 iq_correction;
+    qint32 log2_soft_decim;
+    qint32 lpf_bw;
+    qint32 lpf_fir_enable;
+    qint32 lpf_firbw;
+    qint32 gain;
+    qint32 nco_enable;
+    qint32 nco_frequency;
+    qint32 antenna_path;
+    qint32 gain_mode;
+    qint32 lna_gain;
+    qint32 tia_gain;
+    qint32 pga_gain;
+    qint32 ext_clock;
+    qint32 ext_clock_freq;
+};
+
+}
+
+#endif /* SWGLimeSdrInputSettings_H_ */

swagger/sdrangel/code/qt5/client/SWGLimeSdrOutputSettings.cpp

@@ -0,0 +1,260 @@
+/**
+ * SDRangel
+ * This is the web API of SDRangel SDR software. SDRangel is an Open Source Qt5/OpenGL 3.0+ GUI and server Software Defined Radio and signal analyzer in software. It supports Airspy, BladeRF, HackRF, LimeSDR, PlutoSDR, RTL-SDR, SDRplay RSP1 and FunCube
+ *
+ * OpenAPI spec version: 4.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 "SWGLimeSdrOutputSettings.h"
+
+#include "SWGHelpers.h"
+
+#include <QJsonDocument>
+#include <QJsonArray>
+#include <QObject>
+#include <QDebug>
+
+namespace SWGSDRangel {
+
+SWGLimeSdrOutputSettings::SWGLimeSdrOutputSettings(QString* json) {
+    init();
+    this->fromJson(*json);
+}
+
+SWGLimeSdrOutputSettings::SWGLimeSdrOutputSettings() {
+    init();
+}
+
+SWGLimeSdrOutputSettings::~SWGLimeSdrOutputSettings() {
+    this->cleanup();
+}
+
+void
+SWGLimeSdrOutputSettings::init() {
+    center_frequency = 0L;
+    dev_sample_rate = 0;
+    log2_hard_interp = 0;
+    log2_soft_interp = 0;
+    lpf_bw = 0;
+    lpf_fir_enable = 0;
+    lpf_firbw = 0;
+    gain = 0;
+    nco_enable = 0;
+    nco_frequency = 0;
+    antenna_path = 0;
+    ext_clock = 0;
+    ext_clock_freq = 0;
+}
+
+void
+SWGLimeSdrOutputSettings::cleanup() {
+    
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+SWGLimeSdrOutputSettings*
+SWGLimeSdrOutputSettings::fromJson(QString &json) {
+    QByteArray array (json.toStdString().c_str());
+    QJsonDocument doc = QJsonDocument::fromJson(array);
+    QJsonObject jsonObject = doc.object();
+    this->fromJsonObject(jsonObject);
+    return this;
+}
+
+void
+SWGLimeSdrOutputSettings::fromJsonObject(QJsonObject &pJson) {
+    ::SWGSDRangel::setValue(&center_frequency, pJson["centerFrequency"], "qint64", "");
+    ::SWGSDRangel::setValue(&dev_sample_rate, pJson["devSampleRate"], "qint32", "");
+    ::SWGSDRangel::setValue(&log2_hard_interp, pJson["log2HardInterp"], "qint32", "");
+    ::SWGSDRangel::setValue(&log2_soft_interp, pJson["log2SoftInterp"], "qint32", "");
+    ::SWGSDRangel::setValue(&lpf_bw, pJson["lpfBW"], "qint32", "");
+    ::SWGSDRangel::setValue(&lpf_fir_enable, pJson["lpfFIREnable"], "qint32", "");
+    ::SWGSDRangel::setValue(&lpf_firbw, pJson["lpfFIRBW"], "qint32", "");
+    ::SWGSDRangel::setValue(&gain, pJson["gain"], "qint32", "");
+    ::SWGSDRangel::setValue(&nco_enable, pJson["ncoEnable"], "qint32", "");
+    ::SWGSDRangel::setValue(&nco_frequency, pJson["ncoFrequency"], "qint32", "");
+    ::SWGSDRangel::setValue(&antenna_path, pJson["antennaPath"], "qint32", "");
+    ::SWGSDRangel::setValue(&ext_clock, pJson["extClock"], "qint32", "");
+    ::SWGSDRangel::setValue(&ext_clock_freq, pJson["extClockFreq"], "qint32", "");
+}
+
+QString
+SWGLimeSdrOutputSettings::asJson ()
+{
+    QJsonObject* obj = this->asJsonObject();
+    
+    QJsonDocument doc(*obj);
+    QByteArray bytes = doc.toJson();
+    return QString(bytes);
+}
+
+QJsonObject*
+SWGLimeSdrOutputSettings::asJsonObject() {
+    QJsonObject* obj = new QJsonObject();
+    
+    obj->insert("centerFrequency", QJsonValue(center_frequency));
+
+    obj->insert("devSampleRate", QJsonValue(dev_sample_rate));
+
+    obj->insert("log2HardInterp", QJsonValue(log2_hard_interp));
+
+    obj->insert("log2SoftInterp", QJsonValue(log2_soft_interp));
+
+    obj->insert("lpfBW", QJsonValue(lpf_bw));
+
+    obj->insert("lpfFIREnable", QJsonValue(lpf_fir_enable));
+
+    obj->insert("lpfFIRBW", QJsonValue(lpf_firbw));
+
+    obj->insert("gain", QJsonValue(gain));
+
+    obj->insert("ncoEnable", QJsonValue(nco_enable));
+
+    obj->insert("ncoFrequency", QJsonValue(nco_frequency));
+
+    obj->insert("antennaPath", QJsonValue(antenna_path));
+
+    obj->insert("extClock", QJsonValue(ext_clock));
+
+    obj->insert("extClockFreq", QJsonValue(ext_clock_freq));
+
+    return obj;
+}
+
+qint64
+SWGLimeSdrOutputSettings::getCenterFrequency() {
+    return center_frequency;
+}
+void
+SWGLimeSdrOutputSettings::setCenterFrequency(qint64 center_frequency) {
+    this->center_frequency = center_frequency;
+}
+
+qint32
+SWGLimeSdrOutputSettings::getDevSampleRate() {
+    return dev_sample_rate;
+}
+void
+SWGLimeSdrOutputSettings::setDevSampleRate(qint32 dev_sample_rate) {
+    this->dev_sample_rate = dev_sample_rate;
+}
+
+qint32
+SWGLimeSdrOutputSettings::getLog2HardInterp() {
+    return log2_hard_interp;
+}
+void
+SWGLimeSdrOutputSettings::setLog2HardInterp(qint32 log2_hard_interp) {
+    this->log2_hard_interp = log2_hard_interp;
+}
+
+qint32
+SWGLimeSdrOutputSettings::getLog2SoftInterp() {
+    return log2_soft_interp;
+}
+void
+SWGLimeSdrOutputSettings::setLog2SoftInterp(qint32 log2_soft_interp) {
+    this->log2_soft_interp = log2_soft_interp;
+}
+
+qint32
+SWGLimeSdrOutputSettings::getLpfBw() {
+    return lpf_bw;
+}
+void
+SWGLimeSdrOutputSettings::setLpfBw(qint32 lpf_bw) {
+    this->lpf_bw = lpf_bw;
+}
+
+qint32
+SWGLimeSdrOutputSettings::getLpfFirEnable() {
+    return lpf_fir_enable;
+}
+void
+SWGLimeSdrOutputSettings::setLpfFirEnable(qint32 lpf_fir_enable) {
+    this->lpf_fir_enable = lpf_fir_enable;
+}
+
+qint32
+SWGLimeSdrOutputSettings::getLpfFirbw() {
+    return lpf_firbw;
+}
+void
+SWGLimeSdrOutputSettings::setLpfFirbw(qint32 lpf_firbw) {
+    this->lpf_firbw = lpf_firbw;
+}
+
+qint32
+SWGLimeSdrOutputSettings::getGain() {
+    return gain;
+}
+void
+SWGLimeSdrOutputSettings::setGain(qint32 gain) {
+    this->gain = gain;
+}
+
+qint32
+SWGLimeSdrOutputSettings::getNcoEnable() {
+    return nco_enable;
+}
+void
+SWGLimeSdrOutputSettings::setNcoEnable(qint32 nco_enable) {
+    this->nco_enable = nco_enable;
+}
+
+qint32
+SWGLimeSdrOutputSettings::getNcoFrequency() {
+    return nco_frequency;
+}
+void
+SWGLimeSdrOutputSettings::setNcoFrequency(qint32 nco_frequency) {
+    this->nco_frequency = nco_frequency;
+}
+
+qint32
+SWGLimeSdrOutputSettings::getAntennaPath() {
+    return antenna_path;
+}
+void
+SWGLimeSdrOutputSettings::setAntennaPath(qint32 antenna_path) {
+    this->antenna_path = antenna_path;
+}
+
+qint32
+SWGLimeSdrOutputSettings::getExtClock() {
+    return ext_clock;
+}
+void
+SWGLimeSdrOutputSettings::setExtClock(qint32 ext_clock) {
+    this->ext_clock = ext_clock;
+}
+
+qint32
+SWGLimeSdrOutputSettings::getExtClockFreq() {
+    return ext_clock_freq;
+}
+void
+SWGLimeSdrOutputSettings::setExtClockFreq(qint32 ext_clock_freq) {
+    this->ext_clock_freq = ext_clock_freq;
+}
+
+
+}
+

swagger/sdrangel/code/qt5/client/SWGLimeSdrOutputSettings.h

@@ -0,0 +1,102 @@
+/**
+ * SDRangel
+ * This is the web API of SDRangel SDR software. SDRangel is an Open Source Qt5/OpenGL 3.0+ GUI and server Software Defined Radio and signal analyzer in software. It supports Airspy, BladeRF, HackRF, LimeSDR, PlutoSDR, RTL-SDR, SDRplay RSP1 and FunCube
+ *
+ * OpenAPI spec version: 4.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.
+ */
+
+/*
+ * SWGLimeSdrOutputSettings.h
+ * 
+ * 
+ */
+
+#ifndef SWGLimeSdrOutputSettings_H_
+#define SWGLimeSdrOutputSettings_H_
+
+#include <QJsonObject>
+
+
+
+#include "SWGObject.h"
+
+
+namespace SWGSDRangel {
+
+class SWGLimeSdrOutputSettings: public SWGObject {
+public:
+    SWGLimeSdrOutputSettings();
+    SWGLimeSdrOutputSettings(QString* json);
+    virtual ~SWGLimeSdrOutputSettings();
+    void init();
+    void cleanup();
+
+    QString asJson ();
+    QJsonObject* asJsonObject();
+    void fromJsonObject(QJsonObject &json);
+    SWGLimeSdrOutputSettings* fromJson(QString &jsonString);
+
+    qint64 getCenterFrequency();
+    void setCenterFrequency(qint64 center_frequency);
+
+    qint32 getDevSampleRate();
+    void setDevSampleRate(qint32 dev_sample_rate);
+
+    qint32 getLog2HardInterp();
+    void setLog2HardInterp(qint32 log2_hard_interp);
+
+    qint32 getLog2SoftInterp();
+    void setLog2SoftInterp(qint32 log2_soft_interp);
+
+    qint32 getLpfBw();
+    void setLpfBw(qint32 lpf_bw);
+
+    qint32 getLpfFirEnable();
+    void setLpfFirEnable(qint32 lpf_fir_enable);
+
+    qint32 getLpfFirbw();
+    void setLpfFirbw(qint32 lpf_firbw);
+
+    qint32 getGain();
+    void setGain(qint32 gain);
+
+    qint32 getNcoEnable();
+    void setNcoEnable(qint32 nco_enable);
+
+    qint32 getNcoFrequency();
+    void setNcoFrequency(qint32 nco_frequency);
+
+    qint32 getAntennaPath();
+    void setAntennaPath(qint32 antenna_path);
+
+    qint32 getExtClock();
+    void setExtClock(qint32 ext_clock);
+
+    qint32 getExtClockFreq();
+    void setExtClockFreq(qint32 ext_clock_freq);
+
+
+private:
+    qint64 center_frequency;
+    qint32 dev_sample_rate;
+    qint32 log2_hard_interp;
+    qint32 log2_soft_interp;
+    qint32 lpf_bw;
+    qint32 lpf_fir_enable;
+    qint32 lpf_firbw;
+    qint32 gain;
+    qint32 nco_enable;
+    qint32 nco_frequency;
+    qint32 antenna_path;
+    qint32 ext_clock;
+    qint32 ext_clock_freq;
+};
+
+}
+
+#endif /* SWGLimeSdrOutputSettings_H_ */

swagger/sdrangel/code/qt5/client/SWGModelFactory.h

@@ -24,10 +24,14 @@
 #include "SWGDeviceListItem.h"
 #include "SWGDeviceSet.h"
 #include "SWGDeviceSetList.h"
+#include "SWGDeviceSettings.h"
+#include "SWGDeviceSettingsImpl.h"
 #include "SWGErrorResponse.h"
 #include "SWGInstanceChannelsResponse.h"
 #include "SWGInstanceDevicesResponse.h"
 #include "SWGInstanceSummaryResponse.h"
+#include "SWGLimeSdrInputSettings.h"
+#include "SWGLimeSdrOutputSettings.h"
 #include "SWGLocationInformation.h"
 #include "SWGLoggingInfo.h"
 #include "SWGPresetGroup.h"
@@ -35,6 +39,7 @@
 #include "SWGPresetItem.h"
 #include "SWGPresetTransfer.h"
 #include "SWGPresets.h"
+#include "SWGRtlSdrSettings.h"
 #include "SWGSamplingDevice.h"
 #include "SWGUser.h"
 
@@ -71,6 +76,12 @@ namespace SWGSDRangel {
     if(QString("SWGDeviceSetList").compare(type) == 0) {
       return new SWGDeviceSetList();
     }
+    if(QString("SWGDeviceSettings").compare(type) == 0) {
+      return new SWGDeviceSettings();
+    }
+    if(QString("SWGDeviceSettingsImpl").compare(type) == 0) {
+      return new SWGDeviceSettingsImpl();
+    }
     if(QString("SWGErrorResponse").compare(type) == 0) {
       return new SWGErrorResponse();
     }
@@ -83,6 +94,12 @@ namespace SWGSDRangel {
     if(QString("SWGInstanceSummaryResponse").compare(type) == 0) {
       return new SWGInstanceSummaryResponse();
     }
+    if(QString("SWGLimeSdrInputSettings").compare(type) == 0) {
+      return new SWGLimeSdrInputSettings();
+    }
+    if(QString("SWGLimeSdrOutputSettings").compare(type) == 0) {
+      return new SWGLimeSdrOutputSettings();
+    }
     if(QString("SWGLocationInformation").compare(type) == 0) {
       return new SWGLocationInformation();
     }
@@ -104,6 +121,9 @@ namespace SWGSDRangel {
     if(QString("SWGPresets").compare(type) == 0) {
       return new SWGPresets();
     }
+    if(QString("SWGRtlSdrSettings").compare(type) == 0) {
+      return new SWGRtlSdrSettings();
+    }
     if(QString("SWGSamplingDevice").compare(type) == 0) {
       return new SWGSamplingDevice();
     }

swagger/sdrangel/code/qt5/client/SWGRtlSdrSettings.cpp

@@ -0,0 +1,260 @@
+/**
+ * SDRangel
+ * This is the web API of SDRangel SDR software. SDRangel is an Open Source Qt5/OpenGL 3.0+ GUI and server Software Defined Radio and signal analyzer in software. It supports Airspy, BladeRF, HackRF, LimeSDR, PlutoSDR, RTL-SDR, SDRplay RSP1 and FunCube
+ *
+ * OpenAPI spec version: 4.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 "SWGRtlSdrSettings.h"
+
+#include "SWGHelpers.h"
+
+#include <QJsonDocument>
+#include <QJsonArray>
+#include <QObject>
+#include <QDebug>
+
+namespace SWGSDRangel {
+
+SWGRtlSdrSettings::SWGRtlSdrSettings(QString* json) {
+    init();
+    this->fromJson(*json);
+}
+
+SWGRtlSdrSettings::SWGRtlSdrSettings() {
+    init();
+}
+
+SWGRtlSdrSettings::~SWGRtlSdrSettings() {
+    this->cleanup();
+}
+
+void
+SWGRtlSdrSettings::init() {
+    dev_sample_rate = 0;
+    low_sample_rate = 0;
+    center_frequency = 0L;
+    gain = 0;
+    lo_ppm_correction = 0;
+    log2_decim = 0;
+    fc_pos = 0;
+    dc_block = 0;
+    iq_imbalance = 0;
+    agc = 0;
+    no_mod_mode = 0;
+    transverter_mode = 0;
+    transverter_delta_frequency = 0L;
+}
+
+void
+SWGRtlSdrSettings::cleanup() {
+    
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+SWGRtlSdrSettings*
+SWGRtlSdrSettings::fromJson(QString &json) {
+    QByteArray array (json.toStdString().c_str());
+    QJsonDocument doc = QJsonDocument::fromJson(array);
+    QJsonObject jsonObject = doc.object();
+    this->fromJsonObject(jsonObject);
+    return this;
+}
+
+void
+SWGRtlSdrSettings::fromJsonObject(QJsonObject &pJson) {
+    ::SWGSDRangel::setValue(&dev_sample_rate, pJson["devSampleRate"], "qint32", "");
+    ::SWGSDRangel::setValue(&low_sample_rate, pJson["lowSampleRate"], "qint32", "");
+    ::SWGSDRangel::setValue(&center_frequency, pJson["centerFrequency"], "qint64", "");
+    ::SWGSDRangel::setValue(&gain, pJson["gain"], "qint32", "");
+    ::SWGSDRangel::setValue(&lo_ppm_correction, pJson["loPpmCorrection"], "qint32", "");
+    ::SWGSDRangel::setValue(&log2_decim, pJson["log2Decim"], "qint32", "");
+    ::SWGSDRangel::setValue(&fc_pos, pJson["fcPos"], "qint32", "");
+    ::SWGSDRangel::setValue(&dc_block, pJson["dcBlock"], "qint32", "");
+    ::SWGSDRangel::setValue(&iq_imbalance, pJson["iqImbalance"], "qint32", "");
+    ::SWGSDRangel::setValue(&agc, pJson["agc"], "qint32", "");
+    ::SWGSDRangel::setValue(&no_mod_mode, pJson["noModMode"], "qint32", "");
+    ::SWGSDRangel::setValue(&transverter_mode, pJson["transverterMode"], "qint32", "");
+    ::SWGSDRangel::setValue(&transverter_delta_frequency, pJson["transverterDeltaFrequency"], "qint64", "");
+}
+
+QString
+SWGRtlSdrSettings::asJson ()
+{
+    QJsonObject* obj = this->asJsonObject();
+    
+    QJsonDocument doc(*obj);
+    QByteArray bytes = doc.toJson();
+    return QString(bytes);
+}
+
+QJsonObject*
+SWGRtlSdrSettings::asJsonObject() {
+    QJsonObject* obj = new QJsonObject();
+    
+    obj->insert("devSampleRate", QJsonValue(dev_sample_rate));
+
+    obj->insert("lowSampleRate", QJsonValue(low_sample_rate));
+
+    obj->insert("centerFrequency", QJsonValue(center_frequency));
+
+    obj->insert("gain", QJsonValue(gain));
+
+    obj->insert("loPpmCorrection", QJsonValue(lo_ppm_correction));
+
+    obj->insert("log2Decim", QJsonValue(log2_decim));
+
+    obj->insert("fcPos", QJsonValue(fc_pos));
+
+    obj->insert("dcBlock", QJsonValue(dc_block));
+
+    obj->insert("iqImbalance", QJsonValue(iq_imbalance));
+
+    obj->insert("agc", QJsonValue(agc));
+
+    obj->insert("noModMode", QJsonValue(no_mod_mode));
+
+    obj->insert("transverterMode", QJsonValue(transverter_mode));
+
+    obj->insert("transverterDeltaFrequency", QJsonValue(transverter_delta_frequency));
+
+    return obj;
+}
+
+qint32
+SWGRtlSdrSettings::getDevSampleRate() {
+    return dev_sample_rate;
+}
+void
+SWGRtlSdrSettings::setDevSampleRate(qint32 dev_sample_rate) {
+    this->dev_sample_rate = dev_sample_rate;
+}
+
+qint32
+SWGRtlSdrSettings::getLowSampleRate() {
+    return low_sample_rate;
+}
+void
+SWGRtlSdrSettings::setLowSampleRate(qint32 low_sample_rate) {
+    this->low_sample_rate = low_sample_rate;
+}
+
+qint64
+SWGRtlSdrSettings::getCenterFrequency() {
+    return center_frequency;
+}
+void
+SWGRtlSdrSettings::setCenterFrequency(qint64 center_frequency) {
+    this->center_frequency = center_frequency;
+}
+
+qint32
+SWGRtlSdrSettings::getGain() {
+    return gain;
+}
+void
+SWGRtlSdrSettings::setGain(qint32 gain) {
+    this->gain = gain;
+}
+
+qint32
+SWGRtlSdrSettings::getLoPpmCorrection() {
+    return lo_ppm_correction;
+}
+void
+SWGRtlSdrSettings::setLoPpmCorrection(qint32 lo_ppm_correction) {
+    this->lo_ppm_correction = lo_ppm_correction;
+}
+
+qint32
+SWGRtlSdrSettings::getLog2Decim() {
+    return log2_decim;
+}
+void
+SWGRtlSdrSettings::setLog2Decim(qint32 log2_decim) {
+    this->log2_decim = log2_decim;
+}
+
+qint32
+SWGRtlSdrSettings::getFcPos() {
+    return fc_pos;
+}
+void
+SWGRtlSdrSettings::setFcPos(qint32 fc_pos) {
+    this->fc_pos = fc_pos;
+}
+
+qint32
+SWGRtlSdrSettings::getDcBlock() {
+    return dc_block;
+}
+void
+SWGRtlSdrSettings::setDcBlock(qint32 dc_block) {
+    this->dc_block = dc_block;
+}
+
+qint32
+SWGRtlSdrSettings::getIqImbalance() {
+    return iq_imbalance;
+}
+void
+SWGRtlSdrSettings::setIqImbalance(qint32 iq_imbalance) {
+    this->iq_imbalance = iq_imbalance;
+}
+
+qint32
+SWGRtlSdrSettings::getAgc() {
+    return agc;
+}
+void
+SWGRtlSdrSettings::setAgc(qint32 agc) {
+    this->agc = agc;
+}
+
+qint32
+SWGRtlSdrSettings::getNoModMode() {
+    return no_mod_mode;
+}
+void
+SWGRtlSdrSettings::setNoModMode(qint32 no_mod_mode) {
+    this->no_mod_mode = no_mod_mode;
+}
+
+qint32
+SWGRtlSdrSettings::getTransverterMode() {
+    return transverter_mode;
+}
+void
+SWGRtlSdrSettings::setTransverterMode(qint32 transverter_mode) {
+    this->transverter_mode = transverter_mode;
+}
+
+qint64
+SWGRtlSdrSettings::getTransverterDeltaFrequency() {
+    return transverter_delta_frequency;
+}
+void
+SWGRtlSdrSettings::setTransverterDeltaFrequency(qint64 transverter_delta_frequency) {
+    this->transverter_delta_frequency = transverter_delta_frequency;
+}
+
+
+}
+

swagger/sdrangel/code/qt5/client/SWGRtlSdrSettings.h

@@ -0,0 +1,102 @@
+/**
+ * SDRangel
+ * This is the web API of SDRangel SDR software. SDRangel is an Open Source Qt5/OpenGL 3.0+ GUI and server Software Defined Radio and signal analyzer in software. It supports Airspy, BladeRF, HackRF, LimeSDR, PlutoSDR, RTL-SDR, SDRplay RSP1 and FunCube
+ *
+ * OpenAPI spec version: 4.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.
+ */
+
+/*
+ * SWGRtlSdrSettings.h
+ * 
+ * 
+ */
+
+#ifndef SWGRtlSdrSettings_H_
+#define SWGRtlSdrSettings_H_
+
+#include <QJsonObject>
+
+
+
+#include "SWGObject.h"
+
+
+namespace SWGSDRangel {
+
+class SWGRtlSdrSettings: public SWGObject {
+public:
+    SWGRtlSdrSettings();
+    SWGRtlSdrSettings(QString* json);
+    virtual ~SWGRtlSdrSettings();
+    void init();
+    void cleanup();
+
+    QString asJson ();
+    QJsonObject* asJsonObject();
+    void fromJsonObject(QJsonObject &json);
+    SWGRtlSdrSettings* fromJson(QString &jsonString);
+
+    qint32 getDevSampleRate();
+    void setDevSampleRate(qint32 dev_sample_rate);
+
+    qint32 getLowSampleRate();
+    void setLowSampleRate(qint32 low_sample_rate);
+
+    qint64 getCenterFrequency();
+    void setCenterFrequency(qint64 center_frequency);
+
+    qint32 getGain();
+    void setGain(qint32 gain);
+
+    qint32 getLoPpmCorrection();
+    void setLoPpmCorrection(qint32 lo_ppm_correction);
+
+    qint32 getLog2Decim();
+    void setLog2Decim(qint32 log2_decim);
+
+    qint32 getFcPos();
+    void setFcPos(qint32 fc_pos);
+
+    qint32 getDcBlock();
+    void setDcBlock(qint32 dc_block);
+
+    qint32 getIqImbalance();
+    void setIqImbalance(qint32 iq_imbalance);
+
+    qint32 getAgc();
+    void setAgc(qint32 agc);
+
+    qint32 getNoModMode();
+    void setNoModMode(qint32 no_mod_mode);
+
+    qint32 getTransverterMode();
+    void setTransverterMode(qint32 transverter_mode);
+
+    qint64 getTransverterDeltaFrequency();
+    void setTransverterDeltaFrequency(qint64 transverter_delta_frequency);
+
+
+private:
+    qint32 dev_sample_rate;
+    qint32 low_sample_rate;
+    qint64 center_frequency;
+    qint32 gain;
+    qint32 lo_ppm_correction;
+    qint32 log2_decim;
+    qint32 fc_pos;
+    qint32 dc_block;
+    qint32 iq_imbalance;
+    qint32 agc;
+    qint32 no_mod_mode;
+    qint32 transverter_mode;
+    qint64 transverter_delta_frequency;
+};
+
+}
+
+#endif /* SWGRtlSdrSettings_H_ */