From a3fb30107bef7636d190d2828bfa99b190b06653 Mon Sep 17 00:00:00 2001 From: f4exb Date: Mon, 4 Dec 2017 00:48:14 +0100 Subject: [PATCH] Web API: plugin settings for RTL-SDR and LimeSDR --- .../sdrangel/api/swagger/include/LimeSdr.yaml | 72 ++++ .../sdrangel/api/swagger/include/RtlSdr.yaml | 31 ++ swagger/sdrangel/api/swagger/swagger.yaml | 45 ++- .../code/qt5/client/SWGDeviceSetApi.cpp | 50 +++ .../code/qt5/client/SWGDeviceSetApi.h | 5 + .../code/qt5/client/SWGDeviceSettings.cpp | 112 ++++++ .../code/qt5/client/SWGDeviceSettings.h | 60 +++ .../code/qt5/client/SWGDeviceSettingsImpl.cpp | 129 +++++++ .../code/qt5/client/SWGDeviceSettingsImpl.h | 65 ++++ .../qt5/client/SWGLimeSdrInputSettings.cpp | 344 ++++++++++++++++++ .../code/qt5/client/SWGLimeSdrInputSettings.h | 126 +++++++ .../qt5/client/SWGLimeSdrOutputSettings.cpp | 260 +++++++++++++ .../qt5/client/SWGLimeSdrOutputSettings.h | 102 ++++++ .../code/qt5/client/SWGModelFactory.h | 20 + .../code/qt5/client/SWGRtlSdrSettings.cpp | 260 +++++++++++++ .../code/qt5/client/SWGRtlSdrSettings.h | 102 ++++++ 16 files changed, 1781 insertions(+), 2 deletions(-) create mode 100644 swagger/sdrangel/api/swagger/include/LimeSdr.yaml create mode 100644 swagger/sdrangel/api/swagger/include/RtlSdr.yaml create mode 100644 swagger/sdrangel/code/qt5/client/SWGDeviceSettings.cpp create mode 100644 swagger/sdrangel/code/qt5/client/SWGDeviceSettings.h create mode 100644 swagger/sdrangel/code/qt5/client/SWGDeviceSettingsImpl.cpp create mode 100644 swagger/sdrangel/code/qt5/client/SWGDeviceSettingsImpl.h create mode 100644 swagger/sdrangel/code/qt5/client/SWGLimeSdrInputSettings.cpp create mode 100644 swagger/sdrangel/code/qt5/client/SWGLimeSdrInputSettings.h create mode 100644 swagger/sdrangel/code/qt5/client/SWGLimeSdrOutputSettings.cpp create mode 100644 swagger/sdrangel/code/qt5/client/SWGLimeSdrOutputSettings.h create mode 100644 swagger/sdrangel/code/qt5/client/SWGRtlSdrSettings.cpp create mode 100644 swagger/sdrangel/code/qt5/client/SWGRtlSdrSettings.h diff --git a/swagger/sdrangel/api/swagger/include/LimeSdr.yaml b/swagger/sdrangel/api/swagger/include/LimeSdr.yaml new file mode 100644 index 000000000..dde846255 --- /dev/null +++ b/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 + \ No newline at end of file diff --git a/swagger/sdrangel/api/swagger/include/RtlSdr.yaml b/swagger/sdrangel/api/swagger/include/RtlSdr.yaml new file mode 100644 index 000000000..77f365ef3 --- /dev/null +++ b/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 + \ No newline at end of file diff --git a/swagger/sdrangel/api/swagger/swagger.yaml b/swagger/sdrangel/api/swagger/swagger.yaml index b69be38b6..321c02252 100644 --- a/swagger/sdrangel/api/swagger/swagger.yaml +++ b/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 @@ -914,4 +935,24 @@ definitions: description: "Index of the device set" type: integer preset: - $ref: "#/definitions/PresetIdentifier" + $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" + \ No newline at end of file diff --git a/swagger/sdrangel/code/qt5/client/SWGDeviceSetApi.cpp b/swagger/sdrangel/code/qt5/client/SWGDeviceSetApi.cpp index a1ef22e0e..f72a894b0 100644 --- a/swagger/sdrangel/code/qt5/client/SWGDeviceSetApi.cpp +++ b/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(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; diff --git a/swagger/sdrangel/code/qt5/client/SWGDeviceSetApi.h b/swagger/sdrangel/code/qt5/client/SWGDeviceSetApi.h index 841ccbaf7..0d0ff1dee 100644 --- a/swagger/sdrangel/code/qt5/client/SWGDeviceSetApi.h +++ b/swagger/sdrangel/code/qt5/client/SWGDeviceSetApi.h @@ -17,6 +17,7 @@ #include "SWGDeviceListItem.h" #include "SWGDeviceSet.h" +#include "SWGDeviceSettings.h" #include "SWGErrorResponse.h" #include @@ -35,17 +36,21 @@ public: QString basePath; QMap 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); diff --git a/swagger/sdrangel/code/qt5/client/SWGDeviceSettings.cpp b/swagger/sdrangel/code/qt5/client/SWGDeviceSettings.cpp new file mode 100644 index 000000000..d51e44b4f --- /dev/null +++ b/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 +#include +#include +#include + +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; +} + + +} + diff --git a/swagger/sdrangel/code/qt5/client/SWGDeviceSettings.h b/swagger/sdrangel/code/qt5/client/SWGDeviceSettings.h new file mode 100644 index 000000000..d7b95c1c2 --- /dev/null +++ b/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 + + +#include "SWGObject.h" +#include + +#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_ */ diff --git a/swagger/sdrangel/code/qt5/client/SWGDeviceSettingsImpl.cpp b/swagger/sdrangel/code/qt5/client/SWGDeviceSettingsImpl.cpp new file mode 100644 index 000000000..5fe46456a --- /dev/null +++ b/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 +#include +#include +#include + +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; +} + + +} + diff --git a/swagger/sdrangel/code/qt5/client/SWGDeviceSettingsImpl.h b/swagger/sdrangel/code/qt5/client/SWGDeviceSettingsImpl.h new file mode 100644 index 000000000..d241f037d --- /dev/null +++ b/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 + + +#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_ */ diff --git a/swagger/sdrangel/code/qt5/client/SWGLimeSdrInputSettings.cpp b/swagger/sdrangel/code/qt5/client/SWGLimeSdrInputSettings.cpp new file mode 100644 index 000000000..b4a1bdad2 --- /dev/null +++ b/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 +#include +#include +#include + +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(¢er_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; +} + + +} + diff --git a/swagger/sdrangel/code/qt5/client/SWGLimeSdrInputSettings.h b/swagger/sdrangel/code/qt5/client/SWGLimeSdrInputSettings.h new file mode 100644 index 000000000..4a37c6674 --- /dev/null +++ b/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 + + + +#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_ */ diff --git a/swagger/sdrangel/code/qt5/client/SWGLimeSdrOutputSettings.cpp b/swagger/sdrangel/code/qt5/client/SWGLimeSdrOutputSettings.cpp new file mode 100644 index 000000000..417213951 --- /dev/null +++ b/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 +#include +#include +#include + +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(¢er_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; +} + + +} + diff --git a/swagger/sdrangel/code/qt5/client/SWGLimeSdrOutputSettings.h b/swagger/sdrangel/code/qt5/client/SWGLimeSdrOutputSettings.h new file mode 100644 index 000000000..5d1d7d1ef --- /dev/null +++ b/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 + + + +#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_ */ diff --git a/swagger/sdrangel/code/qt5/client/SWGModelFactory.h b/swagger/sdrangel/code/qt5/client/SWGModelFactory.h index f07a04427..1c230b11d 100644 --- a/swagger/sdrangel/code/qt5/client/SWGModelFactory.h +++ b/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(); } diff --git a/swagger/sdrangel/code/qt5/client/SWGRtlSdrSettings.cpp b/swagger/sdrangel/code/qt5/client/SWGRtlSdrSettings.cpp new file mode 100644 index 000000000..66905e12d --- /dev/null +++ b/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 +#include +#include +#include + +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(¢er_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; +} + + +} + diff --git a/swagger/sdrangel/code/qt5/client/SWGRtlSdrSettings.h b/swagger/sdrangel/code/qt5/client/SWGRtlSdrSettings.h new file mode 100644 index 000000000..da6b9c3b6 --- /dev/null +++ b/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 + + + +#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_ */