2019-05-07 18:30:40 -04:00
///////////////////////////////////////////////////////////////////////////////////
2023-11-19 00:43:20 -05:00
// Copyright (C) 2016, 2019-2020, 2022 Edouard Griffiths, F4EXB <f4exb06@gmail.com> //
// Copyright (C) 2022-2023 Jon Beniston, M7RCE <jon@beniston.com> //
2019-05-07 18:30:40 -04:00
// //
// This program is free software; you can redistribute it and/or modify //
// it under the terms of the GNU General Public License as published by //
// the Free Software Foundation as version 3 of the License, or //
// (at your option) any later version. //
// //
// This program is distributed in the hope that it will be useful, //
// but WITHOUT ANY WARRANTY; without even the implied warranty of //
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
// GNU General Public License V3 for more details. //
// //
// You should have received a copy of the GNU General Public License //
// along with this program. If not, see <http://www.gnu.org/licenses/>. //
///////////////////////////////////////////////////////////////////////////////////
# ifndef SDRBASE_DEVICE_DEVICEAPI_H_
# define SDRBASE_DEVICE_DEVICEAPI_H_
# include <QObject>
# include <QString>
# include <QTimer>
2023-08-24 10:51:50 -04:00
# include "settings/serializableinterface.h"
2019-05-07 18:30:40 -04:00
# include "export.h"
class BasebandSampleSink ;
2019-11-14 19:04:24 -05:00
class BasebandSampleSource ;
2019-09-03 23:00:22 -04:00
class MIMOChannel ;
2019-05-09 11:27:12 -04:00
class ChannelAPI ;
2019-05-07 18:30:40 -04:00
class DeviceSampleSink ;
class DeviceSampleSource ;
2019-05-18 00:30:37 -04:00
class DeviceSampleMIMO ;
2019-05-07 18:30:40 -04:00
class MessageQueue ;
class PluginInterface ;
class DSPDeviceSourceEngine ;
class DSPDeviceSinkEngine ;
2019-05-18 00:30:37 -04:00
class DSPDeviceMIMOEngine ;
2019-05-07 18:30:40 -04:00
class Preset ;
2023-08-24 10:51:50 -04:00
class SDRBASE_API DeviceAPI : public QObject , public SerializableInterface {
2019-05-07 18:30:40 -04:00
Q_OBJECT
public :
enum StreamType //!< This is the same enum as in PluginInterface
{
StreamSingleRx , //!< Exposes a single input stream that can be one of the streams of a physical device
StreamSingleTx , //!< Exposes a single output stream that can be one of the streams of a physical device
2019-05-20 10:31:15 -04:00
StreamMIMO //!< May expose any number of input and/or output streams
2019-05-07 18:30:40 -04:00
} ;
enum EngineState {
StNotStarted , //!< engine is before initialization
StIdle , //!< engine is idle
StReady , //!< engine is ready to run
StRunning , //!< engine is running
StError //!< engine is in error
} ;
DeviceAPI (
StreamType streamType ,
int deviceTabIndex ,
DSPDeviceSourceEngine * deviceSourceEngine ,
2019-05-18 00:30:37 -04:00
DSPDeviceSinkEngine * deviceSinkEngine ,
DSPDeviceMIMOEngine * deviceMIMOEngine
2019-05-07 18:30:40 -04:00
) ;
~ DeviceAPI ( ) ;
2019-05-19 04:23:18 -04:00
void setSpectrumSinkInput ( bool sourceElseSink = true , unsigned int index = 0 ) ; //!< Used in the MIMO case to select which stream is used as input to main spectrum
2019-05-07 18:30:40 -04:00
2019-11-23 01:39:57 -05:00
void addChannelSink ( BasebandSampleSink * sink , int streamIndex = 0 ) ; //!< Add a channel sink (Rx)
void removeChannelSink ( BasebandSampleSink * sink , int streamIndex = 0 ) ; //!< Remove a channel sink (Rx)
2019-11-14 19:04:24 -05:00
void addChannelSource ( BasebandSampleSource * sink , int streamIndex = 0 ) ; //!< Add a channel source (Tx)
void removeChannelSource ( BasebandSampleSource * sink , int streamIndex = 0 ) ; //!< Remove a channel source (Tx)
2019-09-03 23:00:22 -04:00
void addMIMOChannel ( MIMOChannel * channel ) ; //!< Add a MIMO channel (n Rx and m Tx combination)
void removeMIMOChannel ( MIMOChannel * channe ) ; //!< Remove a MIMO channel (n Rx and m Tx combination)
2019-05-07 18:30:40 -04:00
2019-12-23 17:41:35 -05:00
void addChannelSinkAPI ( ChannelAPI * channelAPI ) ;
void removeChannelSinkAPI ( ChannelAPI * channelAPI ) ;
void addChannelSourceAPI ( ChannelAPI * channelAPI ) ;
void removeChannelSourceAPI ( ChannelAPI * channelAPI ) ;
2019-09-03 23:00:22 -04:00
void addMIMOChannelAPI ( ChannelAPI * channelAPI ) ;
void removeMIMOChannelAPI ( ChannelAPI * channelAPI ) ;
2019-05-07 18:30:40 -04:00
void setSampleSource ( DeviceSampleSource * source ) ; //!< Set the device sample source (single Rx)
void setSampleSink ( DeviceSampleSink * sink ) ; //!< Set the device sample sink (single Tx)
2019-05-18 00:30:37 -04:00
void setSampleMIMO ( DeviceSampleMIMO * mimo ) ; //!< Set the device sample MIMO
2019-05-07 18:30:40 -04:00
DeviceSampleSource * getSampleSource ( ) ; //!< Return pointer to the device sample source (single Rx) or nullptr
DeviceSampleSink * getSampleSink ( ) ; //!< Return pointer to the device sample sink (single Tx) or nullptr
2019-05-18 00:30:37 -04:00
DeviceSampleMIMO * getSampleMIMO ( ) ; //!< Return pointer to the device sample MIMO or nullptr
2019-05-07 18:30:40 -04:00
2019-10-20 14:05:01 -04:00
bool initDeviceEngine ( int subsystemIndex = 0 ) ; //!< Init the device engine corresponding to the stream type
bool startDeviceEngine ( int subsystemIndex = 0 ) ; //!< Start the device engine corresponding to the stream type
void stopDeviceEngine ( int subsystemIndex = 0 ) ; //!< Stop the device engine corresponding to the stream type
EngineState state ( int subsystemIndex = 0 ) const ; //!< Return the state of the device engine corresponding to the stream type
QString errorMessage ( int subsystemIndex = 0 ) ; //!< Last error message from the device engine
2019-05-07 18:30:40 -04:00
uint getDeviceUID ( ) const ; //!< Return the current device engine unique ID
MessageQueue * getDeviceEngineInputMessageQueue ( ) ; //!< Device engine message queue
MessageQueue * getSamplingDeviceInputMessageQueue ( ) ; //!< Sampling device (ex: single Rx) input message queue
MessageQueue * getSamplingDeviceGUIMessageQueue ( ) ; //!< Sampling device (ex: single Tx) GUI input message queue
void configureCorrections ( bool dcOffsetCorrection , bool iqImbalanceCorrection , int streamIndex = 0 ) ; //!< Configure current device engine DSP corrections (Rx)
void setHardwareId ( const QString & id ) ;
2019-05-08 16:11:53 -04:00
void setSamplingDeviceId ( const QString & id ) { m_samplingDeviceId = id ; }
void resetSamplingDeviceId ( ) { m_samplingDeviceId . clear ( ) ; }
void setSamplingDeviceSerial ( const QString & serial ) { m_samplingDeviceSerial = serial ; }
void setSamplingDeviceDisplayName ( const QString & name ) { m_samplingDeviceDisplayName = name ; }
void setSamplingDeviceSequence ( int sequence ) { m_samplingDeviceSequence = sequence ; }
2019-06-13 12:43:06 -04:00
void setHardwareUserArguments ( const QString & userArguments ) { m_hardwareUserArguments = userArguments ; }
2019-05-07 18:30:40 -04:00
void setSamplingDevicePluginInterface ( PluginInterface * iface ) ;
const QString & getHardwareId ( ) const { return m_hardwareId ; }
2019-05-08 16:11:53 -04:00
const QString & getSamplingDeviceId ( ) const { return m_samplingDeviceId ; }
const QString & getSamplingDeviceSerial ( ) const { return m_samplingDeviceSerial ; }
const QString & getSamplingDeviceDisplayName ( ) const { return m_samplingDeviceDisplayName ; }
uint32_t getSamplingDeviceSequence ( ) const { return m_samplingDeviceSequence ; }
2019-06-13 12:43:06 -04:00
const QString & getHardwareUserArguments ( ) const { return m_hardwareUserArguments ; }
2019-05-07 18:30:40 -04:00
2022-05-13 16:24:48 -04:00
void setWorkspaceIndex ( int index ) { m_workspaceIndex = index ; }
int getWorkspaceIndex ( ) const { return m_workspaceIndex ; }
2019-05-20 18:27:08 -04:00
void setDeviceNbItems ( uint32_t nbItems ) ;
void setDeviceItemIndex ( uint32_t index ) ;
uint32_t getDeviceNbItems ( ) const { return m_deviceNbItems ; }
uint32_t getDeviceItemIndex ( ) const { return m_deviceItemIndex ; }
2019-05-07 18:30:40 -04:00
int getDeviceSetIndex ( ) const { return m_deviceTabIndex ; }
2022-04-12 10:20:45 -04:00
void setDeviceSetIndex ( int deviceSetIndex ) ;
2019-05-07 18:30:40 -04:00
PluginInterface * getPluginInterface ( ) { return m_pluginInterface ; }
2019-12-23 12:49:06 -05:00
void getDeviceEngineStateStr ( QString & state , int subsystemIndex = 0 ) ;
2019-05-07 18:30:40 -04:00
2019-12-23 12:49:06 -05:00
ChannelAPI * getChanelSinkAPIAt ( int index ) ;
ChannelAPI * getChanelSourceAPIAt ( int index ) ;
ChannelAPI * getMIMOChannelAPIAt ( int index ) ;
2019-05-07 18:30:40 -04:00
int getNbSourceChannels ( ) const { return m_channelSourceAPIs . size ( ) ; }
int getNbSinkChannels ( ) const { return m_channelSinkAPIs . size ( ) ; }
2019-12-23 12:49:06 -05:00
int getNbMIMOChannels ( ) const { return m_mimoChannelAPIs . size ( ) ; }
2019-05-07 18:30:40 -04:00
void loadSamplingDeviceSettings ( const Preset * preset ) ;
// void loadSourceSettings(const Preset* preset);
// void loadSinkSettings(const Preset* preset);
void saveSamplingDeviceSettings ( Preset * preset ) ;
// void saveSourceSettings(Preset* preset);
// void saveSinkSettings(Preset* preset);
2023-08-24 10:51:50 -04:00
QByteArray serialize ( ) const override ;
bool deserialize ( const QByteArray & data ) override ;
// List of one frequency for Single Rx / Tx or one frequency per stream for MIMO
QList < quint64 > getCenterFrequency ( ) const ;
void setCenterFrequency ( QList < quint64 > centerFrequency ) ;
2019-05-07 18:30:40 -04:00
DSPDeviceSourceEngine * getDeviceSourceEngine ( ) { return m_deviceSourceEngine ; }
DSPDeviceSinkEngine * getDeviceSinkEngine ( ) { return m_deviceSinkEngine ; }
2022-01-06 16:47:41 -05:00
DSPDeviceMIMOEngine * getDeviceMIMOEngine ( ) { return m_deviceMIMOEngine ; }
2019-05-07 18:30:40 -04:00
void addSourceBuddy ( DeviceAPI * buddy ) ;
void addSinkBuddy ( DeviceAPI * buddy ) ;
void removeSourceBuddy ( DeviceAPI * buddy ) ;
void removeSinkBuddy ( DeviceAPI * buddy ) ;
void clearBuddiesLists ( ) ;
void * getBuddySharedPtr ( ) const { return m_buddySharedPtr ; }
void setBuddySharedPtr ( void * ptr ) { m_buddySharedPtr = ptr ; }
bool isBuddyLeader ( ) const { return m_isBuddyLeader ; }
void setBuddyLeader ( bool isBuddyLeader ) { m_isBuddyLeader = isBuddyLeader ; }
const std : : vector < DeviceAPI * > & getSourceBuddies ( ) const { return m_sourceBuddies ; }
const std : : vector < DeviceAPI * > & getSinkBuddies ( ) const { return m_sinkBuddies ; }
2019-05-20 18:27:08 -04:00
void setNbSourceStreams ( uint32_t nbSourceStreams ) { m_nbSourceStreams = nbSourceStreams ; }
void setNbSinkStreams ( uint32_t nbSinkStreams ) { m_nbSinkStreams = nbSinkStreams ; }
uint32_t getNbSourceStreams ( ) const { return m_nbSourceStreams ; }
uint32_t getNbSinkStreams ( ) const { return m_nbSinkStreams ; }
2019-05-07 18:30:40 -04:00
const QTimer & getMasterTimer ( ) const { return m_masterTimer ; } //!< This is the DSPEngine master timer
protected :
// common
StreamType m_streamType ;
2019-05-08 16:11:53 -04:00
int m_deviceTabIndex ; //!< This is the tab index in the GUI and also the device set index
QString m_hardwareId ; //!< The internal id that identifies the type of hardware (i.e. HackRF, BladeRF, ...)
2019-05-20 18:27:08 -04:00
uint32_t m_deviceNbItems ; //!< Number of items in the physical device either Rx or Tx. Can be >1 for NxM devices (i.e. 2 for LimeSDR)
uint32_t m_deviceItemIndex ; //!< The item index inb the Rx or Tx side of the physical device. Can be >0 for NxM devices (i.e. 0 or 1 for LimeSDR)
uint32_t m_nbSourceStreams ; //!< The number of source streams in the logical device. 1 for Single Rx (SI) can be 0 or more for MIMO
uint32_t m_nbSinkStreams ; //!< The number of sink streams in the logical device. 1 for Single Tx (SO) can be 0 or more for MIMO
2019-05-07 18:30:40 -04:00
PluginInterface * m_pluginInterface ;
2019-05-08 16:11:53 -04:00
const QTimer & m_masterTimer ; //!< This is the DSPEngine master timer
QString m_samplingDeviceId ; //!< The internal plugin ID corresponding to the device (i.e. for HackRF input, for HackRF output ...)
QString m_samplingDeviceSerial ; //!< The device serial number defined by the vendor or a fake one (SDRplay)
QString m_samplingDeviceDisplayName ; //!< The human readable name identifying this instance
uint32_t m_samplingDeviceSequence ; //!< The device sequence. >0 when more than one device of the same type is connected
2019-06-13 12:43:06 -04:00
QString m_hardwareUserArguments ; //!< User given arguments to be used at hardware level i.e. for the hardware device and device sequence
2022-05-13 16:24:48 -04:00
int m_workspaceIndex ; //!< Used only by the GUI but accessible via web API
2019-05-07 18:30:40 -04:00
// Buddies (single Rx or single Tx)
std : : vector < DeviceAPI * > m_sourceBuddies ; //!< Device source APIs referencing the same physical device
std : : vector < DeviceAPI * > m_sinkBuddies ; //!< Device sink APIs referencing the same physical device
void * m_buddySharedPtr ;
bool m_isBuddyLeader ;
// Single Rx (i.e. source)
DSPDeviceSourceEngine * m_deviceSourceEngine ;
2019-05-09 11:27:12 -04:00
QList < ChannelAPI * > m_channelSinkAPIs ;
2019-05-07 18:30:40 -04:00
// Single Tx (i.e. sink)
DSPDeviceSinkEngine * m_deviceSinkEngine ;
2019-05-09 11:27:12 -04:00
QList < ChannelAPI * > m_channelSourceAPIs ;
2019-05-07 18:30:40 -04:00
2019-05-18 00:30:37 -04:00
// MIMO
DSPDeviceMIMOEngine * m_deviceMIMOEngine ;
2019-09-03 23:00:22 -04:00
QList < ChannelAPI * > m_mimoChannelAPIs ;
2019-05-18 00:30:37 -04:00
2019-05-07 18:30:40 -04:00
private :
void renumerateChannels ( ) ;
2022-08-27 05:18:17 -04:00
private slots :
void engineStateChanged ( ) ;
signals :
void stateChanged ( DeviceAPI * deviceAPI ) ;
2019-05-07 18:30:40 -04:00
} ;
2020-10-02 21:09:36 -04:00
# endif // SDRBASE_DEVICE_DEVICEAPI_H_