VE7UWU/sdrangel
1
0
Fork 0
mirror of https://github.com/f4exb/sdrangel.git synced 2025-04-10 13:40:37 -04:00
Code Issues Projects Releases Wiki Activity

Source plugins: put a serializer and deserializer in the core plugin for server. NFM demod: fixed deserializer

Browse Source
This commit is contained in:
f4exb 2017-12-28 03:21:48 +01:00
parent 1ee6abc3d3
commit 8399baeb4e
36 changed files with 682 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
plugins/channelrx/demodnfm/nfmdemod.cpp
View File

@ -468,19 +468,22 @@ QByteArray NFMDemod::serialize() const
bool NFMDemod::deserialize(const QByteArray& data)
{
if (m_settings.deserialize(data))
{
MsgConfigureNFMDemod *msg = MsgConfigureNFMDemod::create(m_settings, true);
m_inputMessageQueue.push(msg);
return true;
}
else
bool success = true;
if (!m_settings.deserialize(data))
{
m_settings.resetToDefaults();
MsgConfigureNFMDemod *msg = MsgConfigureNFMDemod::create(m_settings, true);
m_inputMessageQueue.push(msg);
return false;
success = false;
}
NFMDemod::MsgConfigureChannelizer* channelConfigMsg = NFMDemod::MsgConfigureChannelizer::create(
48000, m_settings.m_inputFrequencyOffset);
m_inputMessageQueue.push(channelConfigMsg);
MsgConfigureNFMDemod *msg = MsgConfigureNFMDemod::create(m_settings, true);
m_inputMessageQueue.push(msg);
return success;
}
int NFMDemod::webapiSettingsGet(

11
plugins/samplesource/airspy/airspygui.cpp
View File

@ -119,7 +119,16 @@ bool AirspyGui::deserialize(const QByteArray& data)
bool AirspyGui::handleMessage(const Message& message)
{
if (AirspyInput::MsgStartStop::match(message))
if (AirspyInput::MsgConfigureAirspy::match(message))
{
const AirspyInput::MsgConfigureAirspy& cfg = (AirspyInput::MsgConfigureAirspy&) message;
m_settings = cfg.getSettings();
blockApplySettings(true);
displaySettings();
blockApplySettings(false);
return true;
}
else if (AirspyInput::MsgStartStop::match(message))
{
AirspyInput::MsgStartStop& notif = (AirspyInput::MsgStartStop&) message;
blockApplySettings(true);

50
plugins/samplesource/airspy/airspyinput.cpp
View File

@ -213,6 +213,33 @@ void AirspyInput::stop()
m_running = false;
}
QByteArray AirspyInput::serialize() const
{
return m_settings.serialize();
}
bool AirspyInput::deserialize(const QByteArray& data)
{
bool success = true;
if (!m_settings.deserialize(data))
{
m_settings.resetToDefaults();
success = false;
}
MsgConfigureAirspy* message = MsgConfigureAirspy::create(m_settings, true);
m_inputMessageQueue.push(message);
if (m_guiMessageQueue)
{
MsgConfigureAirspy* messageToGUI = MsgConfigureAirspy::create(m_settings, true);
m_guiMessageQueue->push(messageToGUI);
}
return success;
}
const QString& AirspyInput::getDeviceDescription() const
{
return m_deviceDescription;
@ -229,6 +256,21 @@ quint64 AirspyInput::getCenterFrequency() const
return m_settings.m_centerFrequency;
}
void AirspyInput::setCenterFrequency(qint64 centerFrequency)
{
AirspySettings settings = m_settings;
settings.m_centerFrequency = centerFrequency;
MsgConfigureAirspy* message = MsgConfigureAirspy::create(settings, false);
m_inputMessageQueue.push(message);
if (m_guiMessageQueue)
{
MsgConfigureAirspy* messageToGUI = MsgConfigureAirspy::create(settings, false);
m_guiMessageQueue->push(messageToGUI);
}
}
bool AirspyInput::handleMessage(const Message& message)
{
if (MsgConfigureAirspy::match(message))
@ -285,7 +327,7 @@ bool AirspyInput::handleMessage(const Message& message)
}
}
void AirspyInput::setCenterFrequency(quint64 freq_hz)
void AirspyInput::setDeviceCenterFrequency(quint64 freq_hz)
{
qint64 df = ((qint64)freq_hz * m_settings.m_LOppmTenths) / 10000000LL;
freq_hz += df;
@ -294,11 +336,11 @@ void AirspyInput::setCenterFrequency(quint64 freq_hz)
if (rc != AIRSPY_SUCCESS)
{
qWarning("AirspyInput::setCenterFrequency: could not frequency to %llu Hz", freq_hz);
qWarning("AirspyInput::setDeviceCenterFrequency: could not frequency to %llu Hz", freq_hz);
}
else
{
qWarning("AirspyInput::setCenterFrequency: frequency set to %llu Hz", freq_hz);
qWarning("AirspyInput::setDeviceCenterFrequency: frequency set to %llu Hz", freq_hz);
}
}
@ -401,7 +443,7 @@ bool AirspyInput::applySettings(const AirspySettings& settings, bool force)
if (m_dev != 0)
{
setCenterFrequency(deviceCenterFrequency);
setDeviceCenterFrequency(deviceCenterFrequency);
qDebug() << "AirspyInput::applySettings: center freq: " << m_settings.m_centerFrequency << " Hz"
<< " device center freq: " << deviceCenterFrequency << " Hz"

15
plugins/samplesource/airspy/airspyinput.h
View File

@ -17,11 +17,12 @@
#ifndef INCLUDE_AIRSPYINPUT_H
#define INCLUDE_AIRSPYINPUT_H
#include <dsp/devicesamplesource.h>
#include "airspysettings.h"
#include <libairspy/airspy.h>
#include <QString>
#include <QByteArray>
#include <libairspy/airspy.h>
#include <dsp/devicesamplesource.h>
#include "airspysettings.h"
class DeviceSourceAPI;
class AirspyThread;
@ -98,10 +99,14 @@ public:
virtual bool start();
virtual void stop();
virtual QByteArray serialize() const;
virtual bool deserialize(const QByteArray& data);
virtual void setMessageQueueToGUI(MessageQueue *queue) { m_guiMessageQueue = queue; }
virtual const QString& getDeviceDescription() const;
virtual int getSampleRate() const;
virtual quint64 getCenterFrequency() const;
virtual void setCenterFrequency(qint64 centerFrequency);
const std::vector<uint32_t>& getSampleRates() const { return m_sampleRates; }
virtual bool handleMessage(const Message& message);
@ -123,7 +128,7 @@ private:
void closeDevice();
bool applySettings(const AirspySettings& settings, bool force);
struct airspy_device *open_airspy_from_sequence(int sequence);
void setCenterFrequency(quint64 freq);
void setDeviceCenterFrequency(quint64 freq);
DeviceSourceAPI *m_deviceAPI;
QMutex m_mutex;

42
plugins/samplesource/bladerfinput/bladerfinput.cpp
View File

@ -207,6 +207,33 @@ void BladerfInput::stop()
m_running = false;
}
QByteArray BladerfInput::serialize() const
{
return m_settings.serialize();
}
bool BladerfInput::deserialize(const QByteArray& data)
{
bool success = true;
if (!m_settings.deserialize(data))
{
m_settings.resetToDefaults();
success = false;
}
MsgConfigureBladerf* message = MsgConfigureBladerf::create(m_settings, true);
m_inputMessageQueue.push(message);
if (m_guiMessageQueue)
{
MsgConfigureBladerf* messageToGUI = MsgConfigureBladerf::create(m_settings, true);
m_guiMessageQueue->push(messageToGUI);
}
return success;
}
const QString& BladerfInput::getDeviceDescription() const
{
return m_deviceDescription;
@ -223,6 +250,21 @@ quint64 BladerfInput::getCenterFrequency() const
return m_settings.m_centerFrequency;
}
void BladerfInput::setCenterFrequency(qint64 centerFrequency)
{
BladeRFInputSettings settings = m_settings;
settings.m_centerFrequency = centerFrequency;
MsgConfigureBladerf* message = MsgConfigureBladerf::create(settings, false);
m_inputMessageQueue.push(message);
if (m_guiMessageQueue)
{
MsgConfigureBladerf* messageToGUI = MsgConfigureBladerf::create(settings, false);
m_guiMessageQueue->push(messageToGUI);
}
}
bool BladerfInput::handleMessage(const Message& message)
{
if (MsgConfigureBladerf::match(message))

12
plugins/samplesource/bladerfinput/bladerfinput.h
View File

@ -17,13 +17,13 @@
#ifndef INCLUDE_BLADERFINPUT_H
#define INCLUDE_BLADERFINPUT_H
#include <QString>
#include <QByteArray>
#include <libbladeRF.h>
#include <dsp/devicesamplesource.h>
#include "bladerf/devicebladerf.h"
#include "bladerf/devicebladerfparam.h"
#include <libbladeRF.h>
#include <QString>
#include "bladerfinputsettings.h"
class DeviceSourceAPI;
@ -101,10 +101,14 @@ public:
virtual bool start();
virtual void stop();
virtual QByteArray serialize() const;
virtual bool deserialize(const QByteArray& data);
virtual void setMessageQueueToGUI(MessageQueue *queue) { m_guiMessageQueue = queue; }
virtual const QString& getDeviceDescription() const;
virtual int getSampleRate() const;
virtual quint64 getCenterFrequency() const;
virtual void setCenterFrequency(qint64 centerFrequency);
virtual bool handleMessage(const Message& message);

11
plugins/samplesource/bladerfinput/bladerfinputgui.cpp
View File

@ -126,7 +126,16 @@ bool BladerfInputGui::deserialize(const QByteArray& data)
bool BladerfInputGui::handleMessage(const Message& message)
{
if (BladerfInput::MsgStartStop::match(message))
if (BladerfInput::MsgConfigureBladerf::match(message))
{
const BladerfInput::MsgConfigureBladerf& cfg = (BladerfInput::MsgConfigureBladerf&) message;
m_settings = cfg.getSettings();
blockApplySettings(true);
displaySettings();
blockApplySettings(false);
return true;
}
else if (BladerfInput::MsgStartStop::match(message))
{
BladerfInput::MsgStartStop& notif = (BladerfInput::MsgStartStop&) message;
blockApplySettings(true);

11
plugins/samplesource/fcdpro/fcdprogui.cpp
View File

@ -210,7 +210,16 @@ bool FCDProGui::deserialize(const QByteArray& data)
bool FCDProGui::handleMessage(const Message& message __attribute__((unused)))
{
if (FCDProInput::MsgStartStop::match(message))
if (FCDProInput::MsgConfigureFCD::match(message))
{
const FCDProInput::MsgConfigureFCD& cfg = (FCDProInput::MsgConfigureFCD&) message;
m_settings = cfg.getSettings();
blockApplySettings(true);
displaySettings();
blockApplySettings(false);
return true;
}
else if (FCDProInput::MsgStartStop::match(message))
{
FCDProInput::MsgStartStop& notif = (FCDProInput::MsgStartStop&) message;
blockApplySettings(true);

42
plugins/samplesource/fcdpro/fcdproinput.cpp
View File

@ -163,6 +163,33 @@ void FCDProInput::stop()
m_running = false;
}
QByteArray FCDProInput::serialize() const
{
return m_settings.serialize();
}
bool FCDProInput::deserialize(const QByteArray& data)
{
bool success = true;
if (!m_settings.deserialize(data))
{
m_settings.resetToDefaults();
success = false;
}
MsgConfigureFCD* message = MsgConfigureFCD::create(m_settings, true);
m_inputMessageQueue.push(message);
if (m_guiMessageQueue)
{
MsgConfigureFCD* messageToGUI = MsgConfigureFCD::create(m_settings, true);
m_guiMessageQueue->push(messageToGUI);
}
return success;
}
const QString& FCDProInput::getDeviceDescription() const
{
return m_deviceDescription;
@ -178,6 +205,21 @@ quint64 FCDProInput::getCenterFrequency() const
return m_settings.m_centerFrequency;
}
void FCDProInput::setCenterFrequency(qint64 centerFrequency)
{
FCDProSettings settings = m_settings;
settings.m_centerFrequency = centerFrequency;
MsgConfigureFCD* message = MsgConfigureFCD::create(settings, false);
m_inputMessageQueue.push(message);
if (m_guiMessageQueue)
{
MsgConfigureFCD* messageToGUI = MsgConfigureFCD::create(settings, false);
m_guiMessageQueue->push(messageToGUI);
}
}
bool FCDProInput::handleMessage(const Message& message)
{
if(MsgConfigureFCD::match(message))

11
plugins/samplesource/fcdpro/fcdproinput.h
View File

@ -18,12 +18,13 @@
#ifndef INCLUDE_FCDPROINPUT_H
#define INCLUDE_FCDPROINPUT_H
#include <dsp/devicesamplesource.h>
#include <QString>
#include <QByteArray>
#include <inttypes.h>
#include <dsp/devicesamplesource.h>
#include "fcdprosettings.h"
#include "fcdhid.h"
#include <QString>
#include <inttypes.h>
struct fcd_buffer {
void *start;
@ -105,10 +106,14 @@ public:
virtual bool start();
virtual void stop();
virtual QByteArray serialize() const;
virtual bool deserialize(const QByteArray& data);
virtual void setMessageQueueToGUI(MessageQueue *queue) { m_guiMessageQueue = queue; }
virtual const QString& getDeviceDescription() const;
virtual int getSampleRate() const;
virtual quint64 getCenterFrequency() const;
virtual void setCenterFrequency(qint64 centerFrequency);
virtual bool handleMessage(const Message& message);

11
plugins/samplesource/fcdproplus/fcdproplusgui.cpp
View File

@ -128,7 +128,16 @@ bool FCDProPlusGui::deserialize(const QByteArray& data)
bool FCDProPlusGui::handleMessage(const Message& message __attribute__((unused)))
{
if (FCDProPlusInput::MsgStartStop::match(message))
if (FCDProPlusInput::MsgConfigureFCD::match(message))
{
const FCDProPlusInput::MsgConfigureFCD& cfg = (FCDProPlusInput::MsgConfigureFCD&) message;
m_settings = cfg.getSettings();
blockApplySettings(true);
displaySettings();
blockApplySettings(false);
return true;
}
else if (FCDProPlusInput::MsgStartStop::match(message))
{
FCDProPlusInput::MsgStartStop& notif = (FCDProPlusInput::MsgStartStop&) message;
blockApplySettings(true);

42
plugins/samplesource/fcdproplus/fcdproplusinput.cpp
View File

@ -157,6 +157,33 @@ void FCDProPlusInput::stop()
m_running = false;
}
QByteArray FCDProPlusInput::serialize() const
{
return m_settings.serialize();
}
bool FCDProPlusInput::deserialize(const QByteArray& data)
{
bool success = true;
if (!m_settings.deserialize(data))
{
m_settings.resetToDefaults();
success = false;
}
MsgConfigureFCD* message = MsgConfigureFCD::create(m_settings, true);
m_inputMessageQueue.push(message);
if (m_guiMessageQueue)
{
MsgConfigureFCD* messageToGUI = MsgConfigureFCD::create(m_settings, true);
m_guiMessageQueue->push(messageToGUI);
}
return success;
}
const QString& FCDProPlusInput::getDeviceDescription() const
{
return m_deviceDescription;
@ -172,6 +199,21 @@ quint64 FCDProPlusInput::getCenterFrequency() const
return m_settings.m_centerFrequency;
}
void FCDProPlusInput::setCenterFrequency(qint64 centerFrequency)
{
FCDProPlusSettings settings = m_settings;
settings.m_centerFrequency = centerFrequency;
MsgConfigureFCD* message = MsgConfigureFCD::create(settings, false);
m_inputMessageQueue.push(message);
if (m_guiMessageQueue)
{
MsgConfigureFCD* messageToGUI = MsgConfigureFCD::create(settings, false);
m_guiMessageQueue->push(messageToGUI);
}
}
bool FCDProPlusInput::handleMessage(const Message& message)
{
if(MsgConfigureFCD::match(message))

11
plugins/samplesource/fcdproplus/fcdproplusinput.h
View File

@ -17,12 +17,13 @@
#ifndef INCLUDE_FCDINPUT_H
#define INCLUDE_FCDINPUT_H
#include <dsp/devicesamplesource.h>
#include <QString>
#include <QByteArray>
#include <inttypes.h>
#include <dsp/devicesamplesource.h>
#include "fcdproplussettings.h"
#include "fcdhid.h"
#include <QString>
#include <inttypes.h>
struct fcd_buffer {
void *start;
@ -104,10 +105,14 @@ public:
virtual bool start();
virtual void stop();
virtual QByteArray serialize() const;
virtual bool deserialize(const QByteArray& data);
virtual void setMessageQueueToGUI(MessageQueue *queue) { m_guiMessageQueue = queue; }
virtual const QString& getDeviceDescription() const;
virtual int getSampleRate() const;
virtual quint64 getCenterFrequency() const;
virtual void setCenterFrequency(qint64 centerFrequency);
virtual bool handleMessage(const Message& message);

11
plugins/samplesource/filesource/filesourcegui.cpp
View File

@ -156,7 +156,16 @@ void FileSourceGui::handleInputMessages()
bool FileSourceGui::handleMessage(const Message& message)
{
if (FileSourceInput::MsgReportFileSourceAcquisition::match(message))
if (FileSourceInput::MsgConfigureFileSource::match(message))
{
const FileSourceInput::MsgConfigureFileSource& cfg = (FileSourceInput::MsgConfigureFileSource&) message;
m_settings = cfg.getSettings();
blockApplySettings(true);
displaySettings();
blockApplySettings(false);
return true;
}
else if (FileSourceInput::MsgReportFileSourceAcquisition::match(message))
{
m_acquisition = ((FileSourceInput::MsgReportFileSourceAcquisition&)message).getAcquisition();
updateWithAcquisition();

42
plugins/samplesource/filesource/filesourceinput.cpp
View File

@ -189,6 +189,33 @@ void FileSourceInput::stop()
}
}
QByteArray FileSourceInput::serialize() const
{
return m_settings.serialize();
}
bool FileSourceInput::deserialize(const QByteArray& data)
{
bool success = true;
if (!m_settings.deserialize(data))
{
m_settings.resetToDefaults();
success = false;
}
MsgConfigureFileSource* message = MsgConfigureFileSource::create(m_settings);
m_inputMessageQueue.push(message);
if (m_guiMessageQueue)
{
MsgConfigureFileSource* messageToGUI = MsgConfigureFileSource::create(m_settings);
m_guiMessageQueue->push(messageToGUI);
}
return success;
}
const QString& FileSourceInput::getDeviceDescription() const
{
return m_deviceDescription;
@ -204,6 +231,21 @@ quint64 FileSourceInput::getCenterFrequency() const
return m_centerFrequency;
}
void FileSourceInput::setCenterFrequency(qint64 centerFrequency)
{
FileSourceSettings settings = m_settings;
settings.m_centerFrequency = centerFrequency;
MsgConfigureFileSource* message = MsgConfigureFileSource::create(m_settings);
m_inputMessageQueue.push(message);
if (m_guiMessageQueue)
{
MsgConfigureFileSource* messageToGUI = MsgConfigureFileSource::create(m_settings);
m_guiMessageQueue->push(messageToGUI);
}
}
std::time_t FileSourceInput::getStartingTimeStamp() const
{
return m_startingTimeStamp;

7
plugins/samplesource/filesource/filesourceinput.h
View File

@ -17,13 +17,14 @@
#ifndef INCLUDE_FILESOURCEINPUT_H
#define INCLUDE_FILESOURCEINPUT_H
#include <dsp/devicesamplesource.h>
#include <QString>
#include <QByteArray>
#include <QTimer>
#include <ctime>
#include <iostream>
#include <fstream>
#include <dsp/devicesamplesource.h>
#include "filesourcesettings.h"
class FileSourceThread;
@ -230,10 +231,14 @@ public:
virtual bool start();
virtual void stop();
virtual QByteArray serialize() const;
virtual bool deserialize(const QByteArray& data);
virtual void setMessageQueueToGUI(MessageQueue *queue) { m_guiMessageQueue = queue; }
virtual const QString& getDeviceDescription() const;
virtual int getSampleRate() const;
virtual quint64 getCenterFrequency() const;
virtual void setCenterFrequency(qint64 centerFrequency);
std::time_t getStartingTimeStamp() const;
virtual bool handleMessage(const Message& message);

42
plugins/samplesource/hackrfinput/hackrfinput.cpp
View File

@ -188,6 +188,33 @@ void HackRFInput::stop()
m_running = false;
}
QByteArray HackRFInput::serialize() const
{
return m_settings.serialize();
}
bool HackRFInput::deserialize(const QByteArray& data)
{
bool success = true;
if (!m_settings.deserialize(data))
{
m_settings.resetToDefaults();
success = false;
}
MsgConfigureHackRF* message = MsgConfigureHackRF::create(m_settings, true);
m_inputMessageQueue.push(message);
if (m_guiMessageQueue)
{
MsgConfigureHackRF* messageToGUI = MsgConfigureHackRF::create(m_settings, true);
m_guiMessageQueue->push(messageToGUI);
}
return success;
}
const QString& HackRFInput::getDeviceDescription() const
{
return m_deviceDescription;
@ -203,6 +230,21 @@ quint64 HackRFInput::getCenterFrequency() const
return m_settings.m_centerFrequency;
}
void HackRFInput::setCenterFrequency(qint64 centerFrequency)
{
HackRFInputSettings settings = m_settings;
settings.m_centerFrequency = centerFrequency;
MsgConfigureHackRF* message = MsgConfigureHackRF::create(settings, false);
m_inputMessageQueue.push(message);
if (m_guiMessageQueue)
{
MsgConfigureHackRF* messageToGUI = MsgConfigureHackRF::create(settings, false);
m_guiMessageQueue->push(messageToGUI);
}
}
bool HackRFInput::handleMessage(const Message& message)
{
if (MsgConfigureHackRF::match(message))

9
plugins/samplesource/hackrfinput/hackrfinput.h
View File

@ -17,10 +17,11 @@
#ifndef INCLUDE_HACKRFINPUT_H
#define INCLUDE_HACKRFINPUT_H
#include <dsp/devicesamplesource.h>
#include "libhackrf/hackrf.h"
#include <QString>
#include <QByteArray>
#include "libhackrf/hackrf.h"
#include <dsp/devicesamplesource.h>
#include "hackrf/devicehackrf.h"
#include "hackrf/devicehackrfparam.h"
#include "hackrfinputsettings.h"
@ -118,10 +119,14 @@ public:
virtual bool start();
virtual void stop();
virtual QByteArray serialize() const;
virtual bool deserialize(const QByteArray& data);
virtual void setMessageQueueToGUI(MessageQueue *queue) { m_guiMessageQueue = queue; }
virtual const QString& getDeviceDescription() const;
virtual int getSampleRate() const;
virtual quint64 getCenterFrequency() const;
virtual void setCenterFrequency(qint64 centerFrequency);
virtual bool handleMessage(const Message& message);

11
plugins/samplesource/hackrfinput/hackrfinputgui.cpp
View File

@ -125,7 +125,16 @@ bool HackRFInputGui::deserialize(const QByteArray& data)
bool HackRFInputGui::handleMessage(const Message& message)
{
if (HackRFInput::MsgReportHackRF::match(message))
if (HackRFInput::MsgConfigureHackRF::match(message))
{
const HackRFInput::MsgConfigureHackRF& cfg = (HackRFInput::MsgConfigureHackRF&) message;
m_settings = cfg.getSettings();
blockApplySettings(true);
displaySettings();
blockApplySettings(false);
return true;
}
else if (HackRFInput::MsgReportHackRF::match(message))
{
displaySettings();
return true;

42
plugins/samplesource/limesdrinput/limesdrinput.cpp
View File

@ -425,6 +425,33 @@ void LimeSDRInput::stop()
releaseChannel();
}
QByteArray LimeSDRInput::serialize() const
{
return m_settings.serialize();
}
bool LimeSDRInput::deserialize(const QByteArray& data)
{
bool success = true;
if (!m_settings.deserialize(data))
{
m_settings.resetToDefaults();
success = false;
}
MsgConfigureLimeSDR* message = MsgConfigureLimeSDR::create(m_settings, true);
m_inputMessageQueue.push(message);
if (m_guiMessageQueue)
{
MsgConfigureLimeSDR* messageToGUI = MsgConfigureLimeSDR::create(m_settings, true);
m_guiMessageQueue->push(messageToGUI);
}
return success;
}
const QString& LimeSDRInput::getDeviceDescription() const
{
return m_deviceDescription;
@ -441,6 +468,21 @@ quint64 LimeSDRInput::getCenterFrequency() const
return m_settings.m_centerFrequency;
}
void LimeSDRInput::setCenterFrequency(qint64 centerFrequency)
{
LimeSDRInputSettings settings = m_settings;
settings.m_centerFrequency = centerFrequency;
MsgConfigureLimeSDR* message = MsgConfigureLimeSDR::create(settings, false);
m_inputMessageQueue.push(message);
if (m_guiMessageQueue)
{
MsgConfigureLimeSDR* messageToGUI = MsgConfigureLimeSDR::create(settings, false);
m_guiMessageQueue->push(messageToGUI);
}
}
std::size_t LimeSDRInput::getChannelIndex()
{
return m_deviceShared.m_channel;

5
plugins/samplesource/limesdrinput/limesdrinput.h
View File

@ -18,6 +18,7 @@
#define PLUGINS_SAMPLESOURCE_LIMESDRINPUT_LIMESDRINPUT_H_
#include <QString>
#include <QByteArray>
#include <stdint.h>
#include "dsp/devicesamplesource.h"
@ -212,10 +213,14 @@ public:
virtual bool start();
virtual void stop();
virtual QByteArray serialize() const;
virtual bool deserialize(const QByteArray& data);
virtual void setMessageQueueToGUI(MessageQueue *queue) { m_guiMessageQueue = queue; }
virtual const QString& getDeviceDescription() const;
virtual int getSampleRate() const;
virtual quint64 getCenterFrequency() const;
virtual void setCenterFrequency(qint64 centerFrequency);
virtual bool handleMessage(const Message& message);

12
plugins/samplesource/limesdrinput/limesdrinputgui.cpp
View File

@ -140,8 +140,16 @@ bool LimeSDRInputGUI::deserialize(const QByteArray& data)
bool LimeSDRInputGUI::handleMessage(const Message& message)
{
if (DeviceLimeSDRShared::MsgReportBuddyChange::match(message))
if (LimeSDRInput::MsgConfigureLimeSDR::match(message))
{
const LimeSDRInput::MsgConfigureLimeSDR& cfg = (LimeSDRInput::MsgConfigureLimeSDR&) message;
m_settings = cfg.getSettings();
blockApplySettings(true);
displaySettings();
blockApplySettings(false);
return true;
}
else if (DeviceLimeSDRShared::MsgReportBuddyChange::match(message))
{
DeviceLimeSDRShared::MsgReportBuddyChange& report = (DeviceLimeSDRShared::MsgReportBuddyChange&) message;
m_settings.m_devSampleRate = report.getDevSampleRate();

41
plugins/samplesource/plutosdrinput/plutosdrinput.cpp
View File

@ -118,6 +118,33 @@ void PlutoSDRInput::stop()
m_running = false;
}
QByteArray PlutoSDRInput::serialize() const
{
return m_settings.serialize();
}
bool PlutoSDRInput::deserialize(const QByteArray& data)
{
bool success = true;
if (!m_settings.deserialize(data))
{
m_settings.resetToDefaults();
success = false;
}
MsgConfigurePlutoSDR* message = MsgConfigurePlutoSDR::create(m_settings, true);
m_inputMessageQueue.push(message);
if (m_guiMessageQueue)
{
MsgConfigurePlutoSDR* messageToGUI = MsgConfigurePlutoSDR::create(m_settings, true);
m_guiMessageQueue->push(messageToGUI);
}
return success;
}
const QString& PlutoSDRInput::getDeviceDescription() const
{
return m_deviceDescription;
@ -132,6 +159,20 @@ quint64 PlutoSDRInput::getCenterFrequency() const
return m_settings.m_centerFrequency;
}
void PlutoSDRInput::setCenterFrequency(qint64 centerFrequency)
{
PlutoSDRInputSettings settings = m_settings;
settings.m_centerFrequency = centerFrequency;
MsgConfigurePlutoSDR* message = MsgConfigurePlutoSDR::create(m_settings, false);
m_inputMessageQueue.push(message);
if (m_guiMessageQueue)
{
MsgConfigurePlutoSDR* messageToGUI = MsgConfigurePlutoSDR::create(m_settings, false);
m_guiMessageQueue->push(messageToGUI);
}
}
bool PlutoSDRInput::handleMessage(const Message& message)
{

5
plugins/samplesource/plutosdrinput/plutosdrinput.h
View File

@ -18,6 +18,7 @@
#define PLUGINS_SAMPLESOURCE_PLUTOSDRINPUT_PLUTOSDRINPUT_H_
#include <QString>
#include <QByteArray>
#include "iio.h"
#include <dsp/devicesamplesource.h>
@ -100,10 +101,14 @@ public:
virtual bool start();
virtual void stop();
virtual QByteArray serialize() const;
virtual bool deserialize(const QByteArray& data);
virtual void setMessageQueueToGUI(MessageQueue *queue) { m_guiMessageQueue = queue; }
virtual const QString& getDeviceDescription() const;
virtual int getSampleRate() const;
virtual quint64 getCenterFrequency() const;
virtual void setCenterFrequency(qint64 centerFrequency);
virtual bool handleMessage(const Message& message);

11
plugins/samplesource/plutosdrinput/plutosdrinputgui.cpp
View File

@ -131,7 +131,16 @@ bool PlutoSDRInputGui::deserialize(const QByteArray& data)
bool PlutoSDRInputGui::handleMessage(const Message& message __attribute__((unused)))
{
if (PlutoSDRInput::MsgStartStop::match(message))
if (PlutoSDRInput::MsgConfigurePlutoSDR::match(message))
{
const PlutoSDRInput::MsgConfigurePlutoSDR& cfg = (PlutoSDRInput::MsgConfigurePlutoSDR&) message;
m_settings = cfg.getSettings();
blockApplySettings(true);
displaySettings();
blockApplySettings(false);
return true;
}
else if (PlutoSDRInput::MsgStartStop::match(message))
{
PlutoSDRInput::MsgStartStop& notif = (PlutoSDRInput::MsgStartStop&) message;
blockApplySettings(true);

2
plugins/samplesource/rtlsdr/rtlsdrgui.cpp
View File

@ -146,7 +146,7 @@ bool RTLSDRGui::handleMessage(const Message& message)
blockApplySettings(false);
return true;
}
if (RTLSDRInput::MsgStartStop::match(message))
else if (RTLSDRInput::MsgStartStop::match(message))
{
RTLSDRInput::MsgStartStop& notif = (RTLSDRInput::MsgStartStop&) message;
blockApplySettings(true);

42
plugins/samplesource/rtlsdr/rtlsdrinput.cpp
View File

@ -234,6 +234,33 @@ void RTLSDRInput::stop()
m_running = false;
}
QByteArray RTLSDRInput::serialize() const
{
return m_settings.serialize();
}
bool RTLSDRInput::deserialize(const QByteArray& data)
{
bool success = true;
if (!m_settings.deserialize(data))
{
m_settings.resetToDefaults();
success = false;
}
MsgConfigureRTLSDR* message = MsgConfigureRTLSDR::create(m_settings, true);
m_inputMessageQueue.push(message);
if (m_guiMessageQueue)
{
MsgConfigureRTLSDR* messageToGUI = MsgConfigureRTLSDR::create(m_settings, true);
m_guiMessageQueue->push(messageToGUI);
}
return success;
}
const QString& RTLSDRInput::getDeviceDescription() const
{
return m_deviceDescription;
@ -250,6 +277,21 @@ quint64 RTLSDRInput::getCenterFrequency() const
return m_settings.m_centerFrequency;
}
void RTLSDRInput::setCenterFrequency(qint64 centerFrequency)
{
RTLSDRSettings settings = m_settings;
settings.m_centerFrequency = centerFrequency;
MsgConfigureRTLSDR* message = MsgConfigureRTLSDR::create(settings, false);
m_inputMessageQueue.push(message);
if (m_guiMessageQueue)
{
MsgConfigureRTLSDR* messageToGUI = MsgConfigureRTLSDR::create(settings, false);
m_guiMessageQueue->push(messageToGUI);
}
}
bool RTLSDRInput::handleMessage(const Message& message)
{
if (MsgConfigureRTLSDR::match(message))

9
plugins/samplesource/rtlsdr/rtlsdrinput.h
View File

@ -18,11 +18,12 @@
#ifndef INCLUDE_RTLSDRINPUT_H
#define INCLUDE_RTLSDRINPUT_H
#include <dsp/devicesamplesource.h>
#include <QString>
#include <QByteArray>
#include <dsp/devicesamplesource.h>
#include "rtlsdrsettings.h"
#include <rtl-sdr.h>
#include <QString>
class DeviceSourceAPI;
class RTLSDRThread;
@ -99,10 +100,14 @@ public:
virtual bool start();
virtual void stop();
virtual QByteArray serialize() const;
virtual bool deserialize(const QByteArray& data);
virtual void setMessageQueueToGUI(MessageQueue *queue) { m_guiMessageQueue = queue; }
virtual const QString& getDeviceDescription() const;
virtual int getSampleRate() const;
virtual quint64 getCenterFrequency() const;
virtual void setCenterFrequency(qint64 centerFrequency);
virtual bool handleMessage(const Message& message);

11
plugins/samplesource/sdrdaemonsource/sdrdaemonsourcegui.cpp
View File

@ -176,7 +176,16 @@ void SDRdaemonSourceGui::setCenterFrequency(qint64 centerFrequency)
bool SDRdaemonSourceGui::handleMessage(const Message& message)
{
if (SDRdaemonSourceInput::MsgReportSDRdaemonAcquisition::match(message))
if (SDRdaemonSourceInput::MsgConfigureSDRdaemonSource::match(message))
{
const SDRdaemonSourceInput::MsgConfigureSDRdaemonSource& cfg = (SDRdaemonSourceInput::MsgConfigureSDRdaemonSource&) message;
m_settings = cfg.getSettings();
blockApplySettings(true);
displaySettings();
blockApplySettings(false);
return true;
}
else if (SDRdaemonSourceInput::MsgReportSDRdaemonAcquisition::match(message))
{
m_acquisition = ((SDRdaemonSourceInput::MsgReportSDRdaemonAcquisition&)message).getAcquisition();
updateWithAcquisition();

36
plugins/samplesource/sdrdaemonsource/sdrdaemonsourceinput.cpp
View File

@ -102,6 +102,33 @@ void SDRdaemonSourceInput::stop()
m_SDRdaemonUDPHandler->stop();
}
QByteArray SDRdaemonSourceInput::serialize() const
{
return m_settings.serialize();
}
bool SDRdaemonSourceInput::deserialize(const QByteArray& data)
{
bool success = true;
if (!m_settings.deserialize(data))
{
m_settings.resetToDefaults();
success = false;
}
MsgConfigureSDRdaemonSource* message = MsgConfigureSDRdaemonSource::create(m_settings, true);
m_inputMessageQueue.push(message);
if (m_guiMessageQueue)
{
MsgConfigureSDRdaemonSource* messageToGUI = MsgConfigureSDRdaemonSource::create(m_settings, true);
m_guiMessageQueue->push(messageToGUI);
}
return success;
}
void SDRdaemonSourceInput::setMessageQueueToGUI(MessageQueue *queue)
{
m_guiMessageQueue = queue;
@ -131,6 +158,15 @@ quint64 SDRdaemonSourceInput::getCenterFrequency() const
}
}
void SDRdaemonSourceInput::setCenterFrequency(qint64 centerFrequency)
{
SDRdaemonSourceSettings settings = m_settings;
settings.m_centerFrequency = centerFrequency;
MsgConfigureSDRdaemonSource* message = MsgConfigureSDRdaemonSource::create(m_settings, false);
m_inputMessageQueue.push(message);
}
std::time_t SDRdaemonSourceInput::getStartingTimeStamp() const
{
return m_startingTimeStamp;

7
plugins/samplesource/sdrdaemonsource/sdrdaemonsourceinput.h
View File

@ -17,13 +17,14 @@
#ifndef INCLUDE_SDRDAEMONSOURCEINPUT_H
#define INCLUDE_SDRDAEMONSOURCEINPUT_H
#include <dsp/devicesamplesource.h>
#include <QString>
#include <QByteArray>
#include <QTimer>
#include <ctime>
#include <iostream>
#include <stdint.h>
#include <dsp/devicesamplesource.h>
#include "sdrdaemonsourcesettings.h"
class DeviceSourceAPI;
@ -265,10 +266,14 @@ public:
virtual bool start();
virtual void stop();
virtual QByteArray serialize() const;
virtual bool deserialize(const QByteArray& data);
virtual void setMessageQueueToGUI(MessageQueue *queue);
virtual const QString& getDeviceDescription() const;
virtual int getSampleRate() const;
virtual quint64 getCenterFrequency() const;
virtual void setCenterFrequency(qint64 centerFrequency);
std::time_t getStartingTimeStamp() const;
bool isStreaming() const;

11
plugins/samplesource/sdrplay/sdrplaygui.cpp
View File

@ -137,7 +137,16 @@ bool SDRPlayGui::deserialize(const QByteArray& data)
bool SDRPlayGui::handleMessage(const Message& message)
{
if (SDRPlayInput::MsgReportSDRPlayGains::match(message))
if (SDRPlayInput::MsgConfigureSDRPlay::match(message))
{
const SDRPlayInput::MsgConfigureSDRPlay& cfg = (SDRPlayInput::MsgConfigureSDRPlay&) message;
m_settings = cfg.getSettings();
blockApplySettings(true);
displaySettings();
blockApplySettings(false);
return true;
}
else if (SDRPlayInput::MsgReportSDRPlayGains::match(message))
{
qDebug() << "SDRPlayGui::handleMessage: MsgReportSDRPlayGains";

50
plugins/samplesource/sdrplay/sdrplayinput.cpp
View File

@ -217,6 +217,33 @@ void SDRPlayInput::stop()
m_running = false;
}
QByteArray SDRPlayInput::serialize() const
{
return m_settings.serialize();
}
bool SDRPlayInput::deserialize(const QByteArray& data)
{
bool success = true;
if (!m_settings.deserialize(data))
{
m_settings.resetToDefaults();
success = false;
}
MsgConfigureSDRPlay* message = MsgConfigureSDRPlay::create(m_settings, true);
m_inputMessageQueue.push(message);
if (m_guiMessageQueue)
{
MsgConfigureSDRPlay* messageToGUI = MsgConfigureSDRPlay::create(m_settings, true);
m_guiMessageQueue->push(messageToGUI);
}
return success;
}
const QString& SDRPlayInput::getDeviceDescription() const
{
return m_deviceDescription;
@ -233,6 +260,21 @@ quint64 SDRPlayInput::getCenterFrequency() const
return m_settings.m_centerFrequency;
}
void SDRPlayInput::setCenterFrequency(qint64 centerFrequency)
{
SDRPlaySettings settings = m_settings;
settings.m_centerFrequency = centerFrequency;
MsgConfigureSDRPlay* message = MsgConfigureSDRPlay::create(settings, false);
m_inputMessageQueue.push(message);
if (m_guiMessageQueue)
{
MsgConfigureSDRPlay* messageToGUI = MsgConfigureSDRPlay::create(settings, false);
m_guiMessageQueue->push(messageToGUI);
}
}
bool SDRPlayInput::handleMessage(const Message& message)
{
if (MsgConfigureSDRPlay::match(message))
@ -517,7 +559,7 @@ bool SDRPlayInput::applySettings(const SDRPlaySettings& settings, bool forwardCh
if(m_dev != 0)
{
if (setCenterFrequency(deviceCenterFrequency))
if (setDeviceCenterFrequency(deviceCenterFrequency))
{
qDebug() << "SDRPlayInput::applySettings: center freq: " << m_settings.m_centerFrequency << " Hz"
<< " device center freq: " << deviceCenterFrequency << " Hz"
@ -588,7 +630,7 @@ bool SDRPlayInput::applySettings(const SDRPlaySettings& settings, bool forwardCh
return true;
}
bool SDRPlayInput::setCenterFrequency(quint64 freq_hz)
bool SDRPlayInput::setDeviceCenterFrequency(quint64 freq_hz)
{
qint64 df = ((qint64)freq_hz * m_settings.m_LOppmTenths) / 10000000LL;
freq_hz += df;
@ -597,12 +639,12 @@ bool SDRPlayInput::setCenterFrequency(quint64 freq_hz)
if (r != 0)
{
qWarning("SDRPlayInput::setCenterFrequency: could not frequency to %llu Hz", freq_hz);
qWarning("SDRPlayInput::setDeviceCenterFrequency: could not frequency to %llu Hz", freq_hz);
return false;
}
else
{
qWarning("SDRPlayInput::setCenterFrequency: frequency set to %llu Hz", freq_hz);
qWarning("SDRPlayInput::setDeviceCenterFrequency: frequency set to %llu Hz", freq_hz);
return true;
}
}

15
plugins/samplesource/sdrplay/sdrplayinput.h
View File

@ -17,13 +17,14 @@
#ifndef PLUGINS_SAMPLESOURCE_SDRPLAY_SDRPLAYINPUT_H_
#define PLUGINS_SAMPLESOURCE_SDRPLAY_SDRPLAYINPUT_H_
#include <dsp/devicesamplesource.h>
#include "sdrplaysettings.h"
#include <mirisdr.h>
#include <QString>
#include <QByteArray>
#include <stdint.h>
#include <mirisdr.h>
#include <dsp/devicesamplesource.h>
#include "sdrplaysettings.h"
class DeviceSourceAPI;
class SDRPlayThread;
class FileRecord;
@ -136,10 +137,14 @@ public:
virtual bool start();
virtual void stop();
virtual QByteArray serialize() const;
virtual bool deserialize(const QByteArray& data);
virtual void setMessageQueueToGUI(MessageQueue *queue) { m_guiMessageQueue = queue; }
virtual const QString& getDeviceDescription() const;
virtual int getSampleRate() const;
virtual quint64 getCenterFrequency() const;
virtual void setCenterFrequency(qint64 centerFrequency);
virtual bool handleMessage(const Message& message);
@ -158,7 +163,7 @@ private:
bool openDevice();
void closeDevice();
bool applySettings(const SDRPlaySettings& settings, bool forwardChange, bool force);
bool setCenterFrequency(quint64 freq);
bool setDeviceCenterFrequency(quint64 freq);
DeviceSourceAPI *m_deviceAPI;
QMutex m_mutex;

33
sdrbase/device/devicesourceapi.cpp
View File

@ -243,23 +243,28 @@ void DeviceSourceAPI::loadSourceSettings(const Preset* preset)
{
qDebug("DeviceSourceAPI::loadSourceSettings: Loading preset [%s | %s]", qPrintable(preset->getGroup()), qPrintable(preset->getDescription()));
if(m_sampleSourcePluginInstanceUI != 0)
{
const QByteArray* sourceConfig = preset->findBestDeviceConfig(m_sampleSourceId, m_sampleSourceSerial, m_sampleSourceSequence);
const QByteArray* sourceConfig = preset->findBestDeviceConfig(m_sampleSourceId, m_sampleSourceSerial, m_sampleSourceSequence);
qint64 centerFrequency = preset->getCenterFrequency();
qDebug("DeviceSourceAPI::loadSettings: center frequency: %llu Hz", centerFrequency);
if (sourceConfig != 0)
if (sourceConfig != 0)
{
qDebug("DeviceSourceAPI::loadSettings: deserializing source %s[%d]: %s", qPrintable(m_sampleSourceId), m_sampleSourceSequence, qPrintable(m_sampleSourceSerial));
if (m_sampleSourcePluginInstanceUI != 0)
{
qDebug("DeviceSourceAPI::loadSettings: deserializing source %s[%d]: %s", qPrintable(m_sampleSourceId), m_sampleSourceSequence, qPrintable(m_sampleSourceSerial));
m_sampleSourcePluginInstanceUI->deserialize(*sourceConfig);
m_sampleSourcePluginInstanceUI->setCenterFrequency(centerFrequency);
}
else
{
qDebug("DeviceSourceAPI::loadSettings: source %s[%d]: %s not found", qPrintable(m_sampleSourceId), m_sampleSourceSequence, qPrintable(m_sampleSourceSerial));
m_deviceSourceEngine->getSource()->deserialize(*sourceConfig);
m_deviceSourceEngine->getSource()->setCenterFrequency(centerFrequency);
}
qint64 centerFrequency = preset->getCenterFrequency();
qDebug("DeviceSourceAPI::loadSettings: center frequency: %llu Hz", centerFrequency);
m_sampleSourcePluginInstanceUI->setCenterFrequency(centerFrequency);
}
else
{
qDebug("DeviceSourceAPI::loadSettings: source %s[%d]: %s not found", qPrintable(m_sampleSourceId), m_sampleSourceSequence, qPrintable(m_sampleSourceSerial));
}
}
else
@ -272,15 +277,17 @@ void DeviceSourceAPI::saveSourceSettings(Preset* preset)
{
if (preset->isSourcePreset())
{
if(m_sampleSourcePluginInstanceUI != NULL)
qDebug("DeviceSourceAPI::saveSourceSettings: %s saved", qPrintable(m_sampleSourcePluginInstanceUI->getName()));
if (m_sampleSourcePluginInstanceUI != 0)
{
qDebug("DeviceSourceAPI::saveSourceSettings: %s saved", qPrintable(m_sampleSourcePluginInstanceUI->getName()));
preset->addOrUpdateDeviceConfig(m_sampleSourceId, m_sampleSourceSerial, m_sampleSourceSequence, m_sampleSourcePluginInstanceUI->serialize());
preset->setCenterFrequency(m_sampleSourcePluginInstanceUI->getCenterFrequency());
}
else
{
qDebug("DeviceSourceAPI::saveSourceSettings: no source");
preset->addOrUpdateDeviceConfig(m_sampleSourceId, m_sampleSourceSerial, m_sampleSourceSequence, m_deviceSourceEngine->getSource()->serialize());
preset->setCenterFrequency(m_deviceSourceEngine->getSource()->getCenterFrequency());
}
}
else

5
sdrbase/dsp/devicesamplesource.h
View File

@ -19,6 +19,7 @@
#define INCLUDE_SAMPLESOURCE_H
#include <QtGlobal>
#include <QByteArray>
#include "samplesinkfifo.h"
#include "util/message.h"
@ -42,9 +43,13 @@ public:
virtual bool start() = 0;
virtual void stop() = 0;
virtual QByteArray serialize() const = 0;
virtual bool deserialize(const QByteArray& data) = 0;
virtual const QString& getDeviceDescription() const = 0;
virtual int getSampleRate() const = 0; //!< Sample rate exposed by the source
virtual quint64 getCenterFrequency() const = 0; //!< Center frequency exposed by the source
virtual void setCenterFrequency(qint64 centerFrequency) = 0;
virtual bool handleMessage(const Message& message) = 0;