773 lines
17 KiB
C++
773 lines
17 KiB
C++
/**
|
|
* @file cusdr_receiver.cpp
|
|
* @brief cuSDR receiver class
|
|
* @author Hermann von Hasseln, DL3HVH
|
|
* @version 0.1
|
|
* @date 2010-11-12
|
|
*/
|
|
|
|
/* Copyright (C)
|
|
*
|
|
* 2010 - Hermann von Hasseln, DL3HVH
|
|
*
|
|
* 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; either version 2
|
|
* 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 for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
*
|
|
*/
|
|
#define LOG_RECEIVER
|
|
|
|
// use: RECEIVER_DEBUG
|
|
|
|
#include "cusdr_receiver.h"
|
|
|
|
Receiver::Receiver(int rx)
|
|
: QObject()
|
|
, set(Settings::instance())
|
|
, m_filterMode(set->getCurrentFilterMode())
|
|
, m_stopped(false)
|
|
, m_receiver(rx)
|
|
, m_samplerate(set->getSampleRate())
|
|
, m_audioMode(1)
|
|
//, m_calOffset(63.0)
|
|
//, m_calOffset(33.0)
|
|
{
|
|
setReceiverData(set->getReceiverDataList().at(m_receiver));
|
|
|
|
InitCPX(inBuf, BUFFER_SIZE, 0.0f);
|
|
InitCPX(outBuf, BUFFER_SIZE, 0.0f);
|
|
|
|
newSpectrum.resize(BUFFER_SIZE*4);
|
|
|
|
qtdsp = 0;
|
|
|
|
setupConnections();
|
|
|
|
highResTimer = new HResTimer();
|
|
m_displayTime = (int)(1000000.0/set->getFramesPerSecond(m_receiver));
|
|
|
|
m_smeterTime.start();
|
|
}
|
|
|
|
Receiver::~Receiver() {
|
|
|
|
inBuf.clear();
|
|
outBuf.clear();
|
|
|
|
if (qtdsp) {
|
|
|
|
delete qtdsp;
|
|
qtdsp = 0;
|
|
}
|
|
|
|
if (highResTimer) {
|
|
delete highResTimer;
|
|
}
|
|
|
|
m_stopped = false;
|
|
}
|
|
|
|
void Receiver::setupConnections() {
|
|
|
|
CHECKED_CONNECT(
|
|
set,
|
|
SIGNAL(systemStateChanged(
|
|
QObject *,
|
|
QSDR::_Error,
|
|
QSDR::_HWInterfaceMode,
|
|
QSDR::_ServerMode,
|
|
QSDR::_DataEngineState)),
|
|
this,
|
|
SLOT(setSystemState(
|
|
QObject *,
|
|
QSDR::_Error,
|
|
QSDR::_HWInterfaceMode,
|
|
QSDR::_ServerMode,
|
|
QSDR::_DataEngineState)));
|
|
|
|
CHECKED_CONNECT(
|
|
set,
|
|
SIGNAL(mainVolumeChanged(QObject *, int, float)),
|
|
this,
|
|
SLOT(setAudioVolume(QObject *, int, float)));
|
|
|
|
CHECKED_CONNECT(
|
|
set,
|
|
SIGNAL(sampleRateChanged(QObject *, int)),
|
|
this,
|
|
SLOT(setSampleRate(QObject *, int)));
|
|
|
|
CHECKED_CONNECT(
|
|
set,
|
|
SIGNAL(dspModeChanged(QObject *, int, DSPMode)),
|
|
this,
|
|
SLOT(setDspMode(QObject *, int, DSPMode)));
|
|
|
|
CHECKED_CONNECT(
|
|
set,
|
|
SIGNAL(hamBandChanged(QObject *, int, bool, HamBand)),
|
|
this,
|
|
SLOT(setHamBand(QObject *, int, bool, HamBand)));
|
|
|
|
CHECKED_CONNECT(
|
|
set,
|
|
SIGNAL(agcModeChanged(QObject *, int, AGCMode, bool)),
|
|
this,
|
|
SLOT(setAGCMode(QObject *, int, AGCMode, bool)));
|
|
|
|
CHECKED_CONNECT(
|
|
set,
|
|
SIGNAL(agcGainChanged(QObject *, int, int)),
|
|
this,
|
|
SLOT(setAGCGain(QObject *, int, int)));
|
|
|
|
// CHECKED_CONNECT(
|
|
// set,
|
|
// SIGNAL(agcMaximumGain_dBmChanged(QObject *, int, int)),
|
|
// this,
|
|
// SLOT(setAGCMaximumGain_dBm(QObject *, int, int)));
|
|
|
|
CHECKED_CONNECT(
|
|
set,
|
|
SIGNAL(agcMaximumGainChanged_dB(QObject *, int, qreal)),
|
|
this,
|
|
SLOT(setAGCMaximumGain_dB(QObject *, int, qreal)));
|
|
|
|
CHECKED_CONNECT(
|
|
set,
|
|
SIGNAL(agcFixedGainChanged_dB(QObject *, int, qreal)),
|
|
this,
|
|
SLOT(setAGCFixedGain_dB(QObject *, int, qreal)));
|
|
|
|
CHECKED_CONNECT(
|
|
set,
|
|
SIGNAL(agcThresholdChanged_dB(QObject *, int, qreal)),
|
|
this,
|
|
SLOT(setAGCThreshold_dB(QObject *, int, qreal)));
|
|
|
|
CHECKED_CONNECT(
|
|
set,
|
|
SIGNAL(agcHangThresholdChanged(QObject *, int, int)),
|
|
this,
|
|
SLOT(setAGCHangThreshold(QObject *, int, int)));
|
|
|
|
CHECKED_CONNECT(
|
|
set,
|
|
SIGNAL(agcHangLevelChanged_dB(QObject *, int, qreal)),
|
|
this,
|
|
SLOT(setAGCHangLevel_dB(QObject *, int, qreal)));
|
|
|
|
CHECKED_CONNECT(
|
|
set,
|
|
SIGNAL(agcVariableGainChanged_dB(QObject *, int, qreal)),
|
|
this,
|
|
SLOT(setAGCVariableGain_dB(QObject *, int, qreal)));
|
|
|
|
CHECKED_CONNECT(
|
|
set,
|
|
SIGNAL(agcAttackTimeChanged(QObject *, int, qreal)),
|
|
this,
|
|
SLOT(setAGCAttackTime(QObject *, int, qreal)));
|
|
|
|
CHECKED_CONNECT(
|
|
set,
|
|
SIGNAL(agcDecayTimeChanged(QObject *, int, qreal)),
|
|
this,
|
|
SLOT(setAGCDecayTime(QObject *, int, qreal)));
|
|
|
|
CHECKED_CONNECT(
|
|
set,
|
|
SIGNAL(agcHangTimeChanged(QObject *, int, qreal)),
|
|
this,
|
|
SLOT(setAGCHangTime(QObject *, int, qreal)));
|
|
|
|
CHECKED_CONNECT(
|
|
set,
|
|
SIGNAL(filterFrequenciesChanged(QObject *, int, qreal, qreal)),
|
|
this,
|
|
SLOT(setFilterFrequencies(QObject *, int, qreal, qreal)));
|
|
|
|
CHECKED_CONNECT(
|
|
set,
|
|
SIGNAL(framesPerSecondChanged(QObject*, int, int)),
|
|
this,
|
|
SLOT(setFramesPerSecond(QObject*, int, int)));
|
|
|
|
/*CHECKED_CONNECT(
|
|
set,
|
|
SIGNAL(receiverDataReady()),
|
|
this,
|
|
SLOT(dspProcessing()));*/
|
|
}
|
|
|
|
void Receiver::setReceiverData(TReceiver data) {
|
|
|
|
m_receiverData = data;
|
|
|
|
//m_serverMode = m_receiverData.serverMode;
|
|
m_dspCore = m_receiverData.dspCore;
|
|
m_sampleRate = m_receiverData.sampleRate;
|
|
m_hamBand = m_receiverData.hamBand;
|
|
m_dspMode = m_receiverData.dspMode;
|
|
m_dspModeList = m_receiverData.dspModeList;
|
|
m_agcMode = m_receiverData.agcMode;
|
|
m_agcGain = m_receiverData.acgGain;
|
|
m_agcFixedGain_dB = m_receiverData.agcFixedGain_dB;
|
|
m_agcMaximumGain_dB = m_receiverData.agcMaximumGain_dB;
|
|
m_agcHangThreshold = m_receiverData.agcHangThreshold;
|
|
m_agcVariableGain = m_receiverData.agcVariableGain;
|
|
|
|
m_audioVolume = m_receiverData.audioVolume;
|
|
|
|
m_filterLo = m_receiverData.filterLo;
|
|
m_filterHi = m_receiverData.filterHi;
|
|
|
|
m_lastCtrFrequencyList = m_receiverData.lastCenterFrequencyList;
|
|
m_lastVfoFrequencyList = m_receiverData.lastVfoFrequencyList;
|
|
m_mercuryAttenuators = m_receiverData.mercuryAttenuators;
|
|
}
|
|
|
|
bool Receiver::initDSPInterface() {
|
|
if (m_dspCore == QSDR::QtDSP) {
|
|
|
|
if (!initQtDSPInterface()) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool Receiver::initQtDSPInterface() {
|
|
|
|
qtdsp = new QDSPEngine(this, m_receiver, BUFFER_SIZE);
|
|
|
|
if (qtdsp)
|
|
qtdsp->setQtDSPStatus(true);
|
|
else {
|
|
|
|
RECEIVER_DEBUG << "could not start QtDSP for receiver: " << m_receiver;
|
|
qtdsp = 0;
|
|
return false;
|
|
}
|
|
|
|
qtdsp->setVolume(m_audioVolume);
|
|
|
|
DSPMode mode = m_dspModeList.at(m_hamBand);
|
|
RECEIVER_DEBUG << "set DSP mode to: " << set->getDSPModeString(mode);
|
|
|
|
qtdsp->setDSPMode(mode);
|
|
qtdsp->filter->setFilter(
|
|
getFilterFromDSPMode(set->getDefaultFilterList(), mode).filterLo,
|
|
getFilterFromDSPMode(set->getDefaultFilterList(), mode).filterHi);
|
|
qtdsp->wpagc->setMode(m_agcMode);
|
|
qtdsp->wpagc->setAGCFixedGainDb(m_agcFixedGain_dB);
|
|
qtdsp->wpagc->setMaximumGainDb(m_agcMaximumGain_dB);
|
|
|
|
// if (m_agcMode == (AGCMode) agcOFF)
|
|
// set->setAGCFixedGain_dB(this, m_receiver, m_agcFixedGain_dB);
|
|
// else
|
|
// set->setAGCMaximumGain_dB(this, m_receiver, m_agcMaximumGain_dB);
|
|
|
|
RECEIVER_DEBUG << "QtDSP for receiver: " << m_receiver << " started.";
|
|
return true;
|
|
}
|
|
|
|
void Receiver::deleteDSPInterface() {
|
|
|
|
if (m_dspCore == QSDR::QtDSP)
|
|
deleteQtDSP();
|
|
}
|
|
|
|
void Receiver::deleteQtDSP() {
|
|
|
|
if (qtdsp) {
|
|
|
|
delete qtdsp;
|
|
qtdsp = 0;
|
|
}
|
|
}
|
|
|
|
void Receiver::enqueueData() {
|
|
|
|
inQueue.enqueue(inBuf);
|
|
|
|
if (inQueue.isFull()) {
|
|
RECEIVER_DEBUG << "inQueue full!";
|
|
}
|
|
|
|
}
|
|
|
|
void Receiver::stop() {
|
|
|
|
m_mutex.lock();
|
|
m_stopped = true;
|
|
m_mutex.unlock();
|
|
}
|
|
|
|
void Receiver::dspProcessing() {
|
|
|
|
//RECEIVER_DEBUG << "dspProcessing: " << this->thread();
|
|
|
|
//io.mutex.lock();
|
|
qtdsp->processDSP(inBuf, outBuf, BUFFER_SIZE);
|
|
//io.mutex.unlock();
|
|
|
|
// spectrum
|
|
qtdsp->getSpectrum(newSpectrum, set->getFFTMultiplicator(m_receiver));
|
|
if (highResTimer->getElapsedTimeInMicroSec() >= getDisplayDelay()) {
|
|
|
|
emit spectrumBufferChanged(m_receiver, newSpectrum);
|
|
highResTimer->start();
|
|
}
|
|
|
|
if (m_receiver == set->getCurrentReceiver()) {
|
|
// S-Meter
|
|
if (m_smeterTime.elapsed() > 20) {
|
|
|
|
m_sMeterValue = qtdsp->getSMeterInstValue();
|
|
emit sMeterValueChanged(m_receiver, m_sMeterValue);
|
|
m_smeterTime.restart();
|
|
}
|
|
|
|
// process output data
|
|
emit outputBufferSignal(m_receiver, outBuf);
|
|
}
|
|
}
|
|
|
|
void Receiver::setSampleRate(QObject *sender, int value) {
|
|
|
|
Q_UNUSED(sender)
|
|
|
|
if (m_samplerate == value) return;
|
|
|
|
switch (value) {
|
|
|
|
case 48000:
|
|
m_samplerate = value;
|
|
break;
|
|
|
|
case 96000:
|
|
m_samplerate = value;
|
|
break;
|
|
|
|
case 192000:
|
|
m_samplerate = value;
|
|
break;
|
|
|
|
case 384000:
|
|
m_samplerate = value;
|
|
break;
|
|
|
|
default:
|
|
RECEIVER_DEBUG << "invalid sample rate (possible values are: 48, 96, 192, or 384 kHz)!\n";
|
|
break;
|
|
}
|
|
|
|
if (qtdsp)
|
|
qtdsp->setSampleRate(this, m_samplerate);
|
|
else
|
|
RECEIVER_DEBUG << "qtdsp down: cannot set sample rate!\n";
|
|
}
|
|
|
|
void Receiver::setServerMode(QSDR::_ServerMode mode) {
|
|
|
|
m_serverMode = mode;
|
|
}
|
|
|
|
QSDR::_ServerMode Receiver::getServerMode() const {
|
|
|
|
return m_serverMode;
|
|
}
|
|
|
|
QSDR::_DSPCore Receiver::getDSPCoreMode() const {
|
|
|
|
return m_dspCore;
|
|
}
|
|
|
|
//void Receiver::setSocketState(SocketState state) {
|
|
//
|
|
// m_socketState = state;
|
|
//}
|
|
|
|
//Receiver::SocketState Receiver::socketState() const {
|
|
//
|
|
// return m_socketState;
|
|
//}
|
|
|
|
void Receiver::setSystemState(
|
|
QObject *sender,
|
|
QSDR::_Error err,
|
|
QSDR::_HWInterfaceMode hwmode,
|
|
QSDR::_ServerMode mode,
|
|
QSDR::_DataEngineState state)
|
|
{
|
|
Q_UNUSED (sender)
|
|
Q_UNUSED (err)
|
|
|
|
if (m_hwInterface != hwmode)
|
|
m_hwInterface = hwmode;
|
|
|
|
if (m_serverMode != mode)
|
|
m_serverMode = mode;
|
|
|
|
if (m_dataEngineState != state)
|
|
m_dataEngineState = state;
|
|
}
|
|
|
|
void Receiver::setAudioMode(QObject* sender, int mode) {
|
|
|
|
if (sender != this && m_audioMode == mode) return;
|
|
|
|
m_audioMode = mode;
|
|
}
|
|
|
|
//void Receiver::setID(int value) {
|
|
//
|
|
// m_receiverID = value;
|
|
// RECEIVER_DEBUG << "This is receiver " << m_receiverID;
|
|
//}
|
|
|
|
void Receiver::setReceiver(int value) {
|
|
|
|
m_receiver = value;
|
|
}
|
|
|
|
void Receiver::setSampleRate(int value) {
|
|
|
|
m_sampleRate = value;
|
|
}
|
|
|
|
void Receiver::setHamBand(QObject *sender, int rx, bool byBtn, HamBand band) {
|
|
|
|
Q_UNUSED(sender)
|
|
Q_UNUSED(byBtn)
|
|
|
|
if (m_receiver == rx) {
|
|
|
|
if (m_hamBand == band) return;
|
|
m_hamBand = band;
|
|
}
|
|
}
|
|
|
|
void Receiver::setDspMode(QObject *sender, int rx, DSPMode mode) {
|
|
|
|
Q_UNUSED(sender)
|
|
|
|
if (m_receiver != rx) return;
|
|
if (m_dspMode == mode) return;
|
|
|
|
m_dspMode = mode;
|
|
|
|
if (qtdsp) {
|
|
|
|
qtdsp->setDSPMode(mode);
|
|
qtdsp->filter->setFilter(
|
|
getFilterFromDSPMode(set->getDefaultFilterList(), mode).filterLo,
|
|
getFilterFromDSPMode(set->getDefaultFilterList(), mode).filterHi);
|
|
}
|
|
|
|
//QString msg = "[receiver]: set mode for receiver %1 to %2";
|
|
//emit messageEvent(msg.arg(rx).arg(set->getDSPModeString(m_dspMode)));
|
|
}
|
|
|
|
void Receiver::setAGCMode(QObject *sender, int rx, AGCMode mode, bool hang) {
|
|
|
|
Q_UNUSED(sender)
|
|
Q_UNUSED(hang)
|
|
|
|
if (m_receiver != rx) return;
|
|
if (m_agcMode == mode) return;
|
|
|
|
m_agcMode = mode;
|
|
|
|
if (qtdsp) {
|
|
|
|
qtdsp->wpagc->setMode(mode);
|
|
}
|
|
}
|
|
|
|
void Receiver::setAGCGain(QObject *sender, int rx, int value) {
|
|
|
|
Q_UNUSED(sender)
|
|
|
|
if (m_receiver != rx) return;
|
|
if (m_agcGain == value) return;
|
|
|
|
m_agcGain = value;
|
|
|
|
if (qtdsp) {
|
|
|
|
//RECEIVER_DEBUG << "AGCThreshDB (plus offset) = " << m_agcGain - AGCOFFSET;
|
|
//qtdsp->wpagc->setAGCThreshDb(m_filterLo, m_filterHi, BUFFER_SIZE, m_agcGain - AGCOFFSET);
|
|
}
|
|
}
|
|
|
|
void Receiver::setAGCFixedGain_dB(QObject *sender, int rx, qreal value) {
|
|
|
|
Q_UNUSED(sender)
|
|
|
|
if (m_receiver != rx) return;
|
|
if (m_agcFixedGain_dB == value) return;
|
|
|
|
m_agcFixedGain_dB = value;
|
|
|
|
if (qtdsp) {
|
|
|
|
//RECEIVER_DEBUG << "m_agcFixedGain = " << m_agcFixedGain;
|
|
qtdsp->wpagc->setAGCFixedGainDb(m_agcFixedGain_dB);
|
|
}
|
|
}
|
|
|
|
void Receiver::setAGCMaximumGain_dB(QObject *sender, int rx, qreal value) {
|
|
|
|
Q_UNUSED(sender)
|
|
|
|
if (m_receiver != rx) return;
|
|
if (m_agcMaximumGain_dB == value) return;
|
|
|
|
m_agcMaximumGain_dB = value;
|
|
|
|
if (qtdsp) {
|
|
|
|
//RECEIVER_DEBUG << "setAGCMaximumGain_dB = " << m_agcMaximumGain_dB;
|
|
qtdsp->wpagc->setMaximumGainDb(m_agcMaximumGain_dB);
|
|
}
|
|
}
|
|
|
|
void Receiver::setAGCThreshold_dB(QObject *sender, int rx, qreal value) {
|
|
|
|
Q_UNUSED(sender)
|
|
|
|
if (m_receiver != rx) return;
|
|
if (m_agcThreshold_dBm == value) return;
|
|
|
|
m_agcThreshold_dBm = value;
|
|
|
|
if (qtdsp) {
|
|
|
|
//RECEIVER_DEBUG << "AGCThreshDB (minus offset) for Rx " << m_receiver << ": " << m_agcThreshold_dBm - AGCOFFSET;
|
|
qtdsp->wpagc->setAGCThreshDb(m_filterLo, m_filterHi, 2*BUFFER_SIZE, m_agcThreshold_dBm - AGCOFFSET);
|
|
}
|
|
}
|
|
|
|
void Receiver::setAGCHangThreshold(QObject *sender, int rx, int value) {
|
|
|
|
Q_UNUSED(sender)
|
|
|
|
if (m_receiver != rx) return;
|
|
if (m_agcHangThreshold == value) return;
|
|
|
|
m_agcHangThreshold = value;
|
|
if (qtdsp) {
|
|
|
|
RECEIVER_DEBUG << "m_agcHangThreshold =" << m_agcHangThreshold/100.0;
|
|
qtdsp->wpagc->setHangThresh(m_agcHangThreshold/100.0);
|
|
}
|
|
}
|
|
|
|
void Receiver::setAGCHangLevel_dB(QObject *sender, int rx, qreal value) {
|
|
|
|
Q_UNUSED(sender)
|
|
|
|
if (m_receiver != rx) return;
|
|
if (m_agcHangLevel == value) return;
|
|
|
|
m_agcHangLevel = value;
|
|
|
|
if (qtdsp) {
|
|
|
|
//RECEIVER_DEBUG << "m_agcHangLevel = " << m_agcHangLevel - AGCOFFSET;
|
|
qtdsp->wpagc->setHangLevelDb(m_agcHangLevel - AGCOFFSET);
|
|
}
|
|
//set->setAGCHangLeveldB(this, m_receiverID, value);
|
|
}
|
|
|
|
void Receiver::setAGCVariableGain_dB(QObject *sender, int rx, qreal value) {
|
|
|
|
Q_UNUSED(sender)
|
|
|
|
if (m_receiver != rx) return;
|
|
if (m_agcVariableGain == value) return;
|
|
|
|
m_agcVariableGain = value;
|
|
|
|
if (qtdsp) {
|
|
|
|
RECEIVER_DEBUG << "m_agcVariableGain = " << m_agcVariableGain;
|
|
qtdsp->wpagc->setVarGainDb(m_agcVariableGain);
|
|
}
|
|
}
|
|
|
|
void Receiver::setAGCAttackTime(QObject *sender, int rx, qreal value) {
|
|
|
|
Q_UNUSED(sender)
|
|
|
|
if (m_receiver != rx) return;
|
|
if (m_agcAttackTime == value) return;
|
|
|
|
m_agcAttackTime = value;
|
|
|
|
if (qtdsp) {
|
|
|
|
RECEIVER_DEBUG << "m_agcAttackTime = " << m_agcAttackTime;
|
|
qtdsp->wpagc->setTauAttack(m_agcAttackTime);
|
|
}
|
|
}
|
|
|
|
void Receiver::setAGCDecayTime(QObject *sender, int rx, qreal value) {
|
|
|
|
Q_UNUSED(sender)
|
|
|
|
if (m_receiver != rx) return;
|
|
if (m_agcDecayTime == value) return;
|
|
|
|
m_agcDecayTime = value;
|
|
|
|
if (qtdsp) {
|
|
|
|
RECEIVER_DEBUG << "m_agcDecayTime = " << m_agcDecayTime;
|
|
qtdsp->wpagc->setTauDecay(m_agcDecayTime);
|
|
}
|
|
}
|
|
|
|
void Receiver::setAGCHangTime(QObject *sender, int rx, qreal value) {
|
|
|
|
Q_UNUSED(sender)
|
|
|
|
if (m_receiver != rx) return;
|
|
if (m_agcHangTime == value) return;
|
|
|
|
m_agcHangTime = value;
|
|
|
|
if (qtdsp) {
|
|
|
|
RECEIVER_DEBUG << "m_agcHangTime = " << m_agcHangTime;
|
|
qtdsp->wpagc->setHangTime(m_agcHangTime);
|
|
}
|
|
}
|
|
|
|
void Receiver::setAudioVolume(QObject *sender, int rx, float value) {
|
|
|
|
Q_UNUSED(sender)
|
|
|
|
if (m_receiver != rx) return;
|
|
//if (m_audioVolume == value) return;
|
|
|
|
m_audioVolume = value;
|
|
|
|
if (qtdsp) {
|
|
|
|
//RECEIVER_DEBUG << "setAudioVolume =" << m_audioVolume;
|
|
qtdsp->setVolume(value);
|
|
}
|
|
}
|
|
|
|
void Receiver::setFilterFrequencies(QObject *sender, int rx, double low, double high) {
|
|
|
|
Q_UNUSED(sender)
|
|
|
|
if (m_receiver == rx) {
|
|
|
|
if (m_filterLo == low && m_filterHi == high) return;
|
|
m_filterLo = low;
|
|
m_filterHi = high;
|
|
|
|
if (qtdsp) {
|
|
|
|
qtdsp->filter->setFilter((float)low, (float)high);
|
|
qtdsp->wpagc->filterChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
void Receiver::setCtrFrequency(long frequency) {
|
|
|
|
if (m_ctrFrequency == frequency) return;
|
|
m_ctrFrequency = frequency;
|
|
|
|
HamBand band = getBandFromFrequency(set->getBandFrequencyList(), frequency);
|
|
m_lastCtrFrequencyList[(int) band] = m_ctrFrequency;
|
|
}
|
|
|
|
void Receiver::setVfoFrequency(long frequency) {
|
|
|
|
if (m_vfoFrequency == frequency) return;
|
|
m_vfoFrequency = frequency;
|
|
|
|
HamBand band = getBandFromFrequency(set->getBandFrequencyList(), frequency);
|
|
m_lastVfoFrequencyList[(int) band] = m_vfoFrequency;
|
|
}
|
|
|
|
void Receiver::setLastCtrFrequencyList(const QList<long> &fList) {
|
|
|
|
m_lastCtrFrequencyList = fList;
|
|
}
|
|
|
|
void Receiver::setLastVfoFrequencyList(const QList<long> &fList) {
|
|
|
|
m_lastVfoFrequencyList = fList;
|
|
}
|
|
|
|
void Receiver::setdBmPanScaleMin(qreal value) {
|
|
|
|
if (m_dBmPanScaleMin == value) return;
|
|
m_dBmPanScaleMin = value;
|
|
}
|
|
|
|
void Receiver::setdBmPanScaleMax(qreal value) {
|
|
|
|
if (m_dBmPanScaleMax == value) return;
|
|
m_dBmPanScaleMax = value;
|
|
}
|
|
|
|
void Receiver::setMercuryAttenuators(const QList<int> &attenuators) {
|
|
|
|
m_mercuryAttenuators = attenuators;
|
|
}
|
|
|
|
void Receiver::setFramesPerSecond(QObject *sender, int rx, int value) {
|
|
|
|
Q_UNUSED(sender)
|
|
|
|
if (m_receiver == rx)
|
|
m_displayTime = (int)(1000000.0/value);
|
|
}
|
|
|
|
void Receiver::setPeerAddress(QHostAddress addr) {
|
|
|
|
m_peerAddress = addr;
|
|
}
|
|
|
|
void Receiver::setSocketDescriptor(int value) {
|
|
|
|
m_socketDescriptor = value;
|
|
}
|
|
|
|
void Receiver::setClient(int value) {
|
|
|
|
m_client = value;
|
|
}
|
|
|
|
void Receiver::setIQPort(int value) {
|
|
|
|
m_iqPort = value;
|
|
}
|
|
|
|
void Receiver::setBSPort(int value) {
|
|
|
|
m_bsPort = value;
|
|
}
|
|
|
|
void Receiver::setConnectedStatus(bool value) {
|
|
|
|
m_connected = value;
|
|
}
|