You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
166 lines
7.5 KiB
166 lines
7.5 KiB
/////////////////////////////////////////////////////////////////////////////////// |
|
// Copyright (C) 2017-2019, 2021 Edouard Griffiths, F4EXB <f4exb06@gmail.com> // |
|
// Copyright (C) 2019 Robin Getz <robin.getz@analog.com> // |
|
// Copyright (C) 2020 Felix Schneider <felix@fx-schneider.de> // |
|
// // |
|
// 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 DEVICES_PLUTOSDR_DEVICEPLUTOSDRBOX_H_ |
|
#define DEVICES_PLUTOSDR_DEVICEPLUTOSDRBOX_H_ |
|
|
|
#include <sstream> |
|
#include <stdint.h> |
|
#include <sys/types.h> |
|
|
|
#include <QList> |
|
#include <QString> |
|
|
|
#include "deviceplutosdrscan.h" |
|
#include "export.h" |
|
|
|
#if defined(_MSC_VER) |
|
#include <BaseTsd.h> |
|
typedef SSIZE_T ssize_t; |
|
#endif |
|
|
|
struct iio_channel; |
|
struct iio_channels_mask; // libiio 1.x |
|
struct iio_stream; // libiio 1.x |
|
struct iio_block; // libiio 1.x |
|
|
|
class DEVICES_API DevicePlutoSDRBox |
|
{ |
|
public: |
|
typedef enum |
|
{ |
|
DEVICE_PHY, |
|
DEVICE_RX, |
|
DEVICE_TX |
|
} DeviceType; |
|
|
|
typedef enum |
|
{ |
|
USE_RX, |
|
USE_TX |
|
} DeviceUse; |
|
|
|
struct Sample { |
|
int16_t i; |
|
int16_t q; |
|
}; |
|
|
|
struct SampleRates { |
|
uint32_t m_bbRateHz; //!< Baseband PLL rate (Hz) - used internally |
|
uint32_t m_addaConnvRate; //!< A/D or D/A converter rat - this is the HB3 working sample rate |
|
uint32_t m_hb3Rate; //!< Rate of the HB3/(DEC3 or INT3) filter (Rx: out, Tx: in) - this is the HB2 working sample rate |
|
uint32_t m_hb2Rate; //!< Rate of the HB2 filter (Rx: out, Tx: in) - this is the HB1 working sample rate |
|
uint32_t m_hb1Rate; //!< Rate of the HB1 filter (Rx: out, Tx: in) - this is the FIR working sample rate |
|
uint32_t m_firRate; //!< Rate of FIR filter (Rx: out, Tx: in) - this is the host/device communication sample rate |
|
}; |
|
|
|
uint64_t m_devSampleRate; //!< Host interface sample rate |
|
int32_t m_LOppmTenths; //!< XO correction |
|
bool m_lpfFIREnable; //!< enable digital lowpass FIR filter |
|
float m_lpfFIRBW; //!< digital lowpass FIR filter bandwidth (Hz) |
|
uint32_t m_lpfFIRlog2Decim; //!< digital lowpass FIR filter log2 of decimation factor (0..2) |
|
int m_lpfFIRRxGain; //!< digital lowpass FIR filter gain Rx side (dB) |
|
int m_lpfFIRTxGain; //!< digital lowpass FIR filter gain Tx side (dB) |
|
|
|
DevicePlutoSDRBox(const std::string& uri); |
|
~DevicePlutoSDRBox(); |
|
bool isValid() const { return m_valid; } |
|
static bool probeURI(const std::string& uri); |
|
|
|
void set_params(DeviceType devType, const std::vector<std::string> ¶ms); |
|
bool get_param(DeviceType devType, const std::string ¶m, std::string &value); |
|
bool openRx(); //!< Open first Rx (Rx0) |
|
bool openTx(); //!< Open first Tx (Tx0) |
|
bool openSecondRx(); //!< Open second Rx (Rx1) |
|
bool openSecondTx(); //!< Open second Tx (Tx1) |
|
void closeRx(); //!< Close first Rx (Rx0) |
|
void closeTx(); //!< Close first Tx (Tx0) |
|
void closeSecondRx(); //!< Close second Rx (Rx1) |
|
void closeSecondTx(); //!< Close second Tx (Tx1) |
|
void setRxLOPowerdown(bool powerdown); //!< Power down (true) or up (false) the Rx LO |
|
void setTxLOPowerdown(bool powerdown); //!< Power down (true) or up (false) the Tx LO |
|
int getNbRx() const { return m_rxChannels.size() / 2; } |
|
int getNbTx() const { return m_txChannels.size() / 2; } |
|
int getRxSampleBytes() const { return m_rxSampleBytes; } |
|
int getTxSampleBytes() const { return m_txSampleBytes; } |
|
struct iio_buffer *createRxBuffer(unsigned int size, bool cyclic); |
|
struct iio_buffer *createTxBuffer(unsigned int size, bool cyclic); |
|
void deleteRxBuffer(); |
|
void deleteTxBuffer(); |
|
ssize_t getRxSampleSize(); |
|
ssize_t getTxSampleSize(); |
|
ssize_t rxBufferRefill(); |
|
ssize_t txBufferPush(); |
|
std::ptrdiff_t rxBufferStep(); |
|
char* rxBufferEnd(); |
|
char* rxBufferFirst(); |
|
std::ptrdiff_t txBufferStep(); |
|
char* txBufferEnd(); |
|
char* txBufferFirst(); |
|
void txChannelConvert(int16_t *dst, int16_t *src); |
|
void txChannelConvert(int chanIndex, int16_t *dst, int16_t *src); |
|
bool getRxSampleRates(SampleRates& sampleRates); |
|
bool getTxSampleRates(SampleRates& sampleRates); |
|
void setSampleRate(uint32_t sampleRate); |
|
void setFIR(uint32_t sampleRate, uint32_t intdec, DeviceUse use, uint32_t bw, int gain); |
|
void setFIREnable(bool enable); |
|
void setLOPPMTenths(int ppmTenths); |
|
bool getRxGain(int& gaindB, unsigned int chan); |
|
bool getRxRSSI(std::string& rssiStr, unsigned int chan); |
|
bool getTxRSSI(std::string& rssiStr, unsigned int chan); |
|
void getGainRange(qint64& minGain, qint64& stepGain, qint64& maxGain); |
|
void getRxLORange(uint64_t& minLimit, uint64_t& maxLimit); |
|
void getTxLORange(uint64_t& minLimit, uint64_t& maxLimit); |
|
void getbbLPRxRange(uint32_t& minLimit, uint32_t& maxLimit); |
|
void getbbLPTxRange(uint32_t& minLimit, uint32_t& maxLimit); |
|
bool fetchTemp(); |
|
float getTemp() const { return m_temp; } |
|
bool getRateGovernors(std::string& rateGovernors); |
|
|
|
private: |
|
struct iio_context *m_ctx; |
|
struct iio_device *m_devPhy; |
|
struct iio_device *m_devRx; |
|
struct iio_device *m_devTx; |
|
struct iio_buffer *m_rxBuf; |
|
struct iio_buffer *m_txBuf; |
|
struct iio_channels_mask *m_rxMask; //!< libiio 1.x: Rx channels enabled for streaming |
|
struct iio_stream *m_rxStream; //!< libiio 1.x: Rx block stream |
|
const struct iio_block *m_rxBlock; //!< libiio 1.x: last Rx block received |
|
struct iio_channels_mask *m_txMask; //!< libiio 1.x: Tx channels enabled for streaming |
|
struct iio_stream *m_txStream; //!< libiio 1.x: Tx block stream |
|
const struct iio_block *m_txBlock; //!< libiio 1.x: Tx block being filled |
|
bool m_valid; |
|
int64_t m_xoInitial; |
|
float m_temp; |
|
int m_rxSampleBytes; //!< size in bytes of a Rx I or Q sample. Rx must be opened. |
|
int m_txSampleBytes; //!< size in bytes of a Tx I or Q sample. Tx must be opened. |
|
QList<QString> m_rxChannelIds; |
|
QList<iio_channel*> m_rxChannels; |
|
QList<QString> m_txChannelIds; |
|
QList<iio_channel*> m_txChannels; |
|
|
|
bool parseSampleRates(const std::string& rateStr, SampleRates& sampleRates); |
|
void setFilter(const std::string& filterConfigStr); |
|
void formatFIRHeader(std::ostringstream& str, uint32_t intdec); |
|
void formatFIRCoefficients(std::ostringstream& str, uint32_t nbTaps, double normalizedBW); |
|
void getXO(); |
|
}; |
|
|
|
#endif /* DEVICES_PLUTOSDR_DEVICEPLUTOSDRBOX_H_ */
|
|
|