void DATVDemodGUI::resetToDefaults()
{
blockApplySettings(true);
ui->chkAllowDrift->setChecked(false);
ui->chkFastlock->setChecked(true);
ui->chkHardMetric->setChecked(false);
ui->chkViterbi->setChecked(false);
ui->cmbFEC->setCurrentIndex(0);
ui->cmbModulation->setCurrentIndex(0);
ui->cmbStandard->setCurrentIndex(0);
ui->cmbFilter->setCurrentIndex(0);
displayRRCParameters(false);
ui->spiNotchFilters->setValue(0);
ui->prgSynchro->setValue(0);
ui->lblStatus->setText("");
ui->rfBandwidth->setValue(512000);
ui->spiSymbolRate->setValue(250000);
ui->spiRollOff->setValue(35);
ui->spiExcursion->setValue(10);
blockApplySettings(false);
applySettings();
}
bool Bladerf1OutputGui::handleMessage(const Message& message)
{
if (Bladerf1Output::MsgConfigureBladerf1::match(message))
{
const Bladerf1Output::MsgConfigureBladerf1& cfg = (Bladerf1Output::MsgConfigureBladerf1&) message;
m_settings = cfg.getSettings();
blockApplySettings(true);
displaySettings();
blockApplySettings(false);
return true;
}
else if (Bladerf1Output::MsgReportBladerf1::match(message))
{
displaySettings();
return true;
}
else if (Bladerf1Output::MsgStartStop::match(message))
{
Bladerf1Output::MsgStartStop& notif = (Bladerf1Output::MsgStartStop&) message;
blockApplySettings(true);
ui->startStop->setChecked(notif.getStartStop());
blockApplySettings(false);
return true;
}
else
{
return false;
}
}
bool AirspyGui::handleMessage(const Message& 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);
ui->startStop->setChecked(notif.getStartStop());
blockApplySettings(false);
return true;
}
else
{
return false;
}
}
void SDRdaemonSinkGui::resetToDefaults()
{
blockApplySettings(true);
m_settings.resetToDefaults();
displaySettings();
blockApplySettings(false);
sendSettings();
}
void SDRdaemonSourceGui::updateSampleRateAndFrequency()
{
m_deviceUISet->getSpectrum()->setSampleRate(m_streamSampleRate);
m_deviceUISet->getSpectrum()->setCenterFrequency(m_streamCenterFrequency);
ui->deviceRateText->setText(tr("%1k").arg((float)m_streamSampleRate / 1000));
blockApplySettings(true);
ui->centerFrequency->setValue(m_streamCenterFrequency / 1000);
blockApplySettings(false);
}
void AMDemodGUI::resetToDefaults()
{
blockApplySettings(true);
ui->rfBW->setValue(50);
ui->volume->setValue(20);
ui->squelch->setValue(-40);
ui->deltaFrequency->setValue(0);
blockApplySettings(false);
applySettings();
}
void ChannelAnalyzerGUI::displaySettings()
{
m_channelMarker.blockSignals(true);
m_channelMarker.setCenterFrequency(m_settings.m_frequency);
m_channelMarker.setBandwidth(m_settings.m_bandwidth * 2);
m_channelMarker.setTitle(m_settings.m_title);
m_channelMarker.setLowCutoff(m_settings.m_lowCutoff);
if (m_settings.m_ssb)
{
if (m_settings.m_bandwidth < 0) {
m_channelMarker.setSidebands(ChannelMarker::lsb);
} else {
m_channelMarker.setSidebands(ChannelMarker::usb);
}
}
else
{
m_channelMarker.setSidebands(ChannelMarker::dsb);
}
m_channelMarker.blockSignals(false);
m_channelMarker.setColor(m_settings.m_rgbColor); // activate signal on the last setting only
setTitleColor(m_settings.m_rgbColor);
setWindowTitle(m_channelMarker.getTitle());
ui->channelSampleRate->setValueRange(7, 0.501*m_channelAnalyzer->getInputSampleRate(), m_channelAnalyzer->getInputSampleRate());
ui->channelSampleRate->setValue(m_settings.m_downSampleRate);
blockApplySettings(true);
ui->useRationalDownsampler->setChecked(m_settings.m_downSample);
setNewFinalRate();
if (m_settings.m_ssb) {
ui->BWLabel->setText("LP");
} else {
ui->BWLabel->setText("BP");
}
ui->ssb->setChecked(m_settings.m_ssb);
ui->BW->setValue(m_settings.m_bandwidth/100);
ui->lowCut->setValue(m_settings.m_lowCutoff/100);
ui->deltaFrequency->setValue(m_settings.m_frequency);
ui->spanLog2->setCurrentIndex(m_settings.m_spanLog2);
displayPLLSettings();
ui->signalSelect->setCurrentIndex((int) m_settings.m_inputType);
ui->rrcFilter->setChecked(m_settings.m_rrc);
QString rolloffStr = QString::number(m_settings.m_rrcRolloff/100.0, 'f', 2);
ui->rrcRolloffText->setText(rolloffStr);
blockApplySettings(false);
}
void NFMDemodGUI::displaySettings()
{
m_channelMarker.blockSignals(true);
m_channelMarker.setCenterFrequency(m_settings.m_inputFrequencyOffset);
m_channelMarker.setBandwidth(m_settings.m_rfBandwidth);
m_channelMarker.setTitle(m_settings.m_title);
m_channelMarker.blockSignals(false);
m_channelMarker.setColor(m_settings.m_rgbColor);
setTitleColor(m_settings.m_rgbColor);
setWindowTitle(m_channelMarker.getTitle());
blockApplySettings(true);
ui->deltaFrequency->setValue(m_channelMarker.getCenterFrequency());
ui->rfBW->setCurrentIndex(NFMDemodSettings::getRFBWIndex(m_settings.m_rfBandwidth));
ui->afBWText->setText(QString("%1 k").arg(m_settings.m_afBandwidth / 1000.0));
ui->afBW->setValue(m_settings.m_afBandwidth / 1000.0);
ui->volumeText->setText(QString("%1").arg(m_settings.m_volume, 0, 'f', 1));
ui->volume->setValue(m_settings.m_volume * 10.0);
ui->squelchGateText->setText(QString("%1").arg(m_settings.m_squelchGate * 10.0f, 0, 'f', 0));
ui->squelchGate->setValue(m_settings.m_squelchGate);
ui->deltaSquelch->setChecked(m_settings.m_deltaSquelch);
ui->squelch->setValue(m_settings.m_squelch * 1.0);
if (m_settings.m_deltaSquelch)
{
ui->squelchText->setText(QString("%1").arg((-m_settings.m_squelch) / 1.0, 0, 'f', 0));
ui->squelchText->setToolTip(tr("Squelch AF balance threshold (%)"));
ui->squelch->setToolTip(tr("Squelch AF balance threshold (%)"));
}
else
{
ui->squelchText->setText(QString("%1").arg(m_settings.m_squelch / 1.0, 0, 'f', 0));
ui->squelchText->setToolTip(tr("Squelch power threshold (dB)"));
ui->squelch->setToolTip(tr("Squelch power threshold (dB)"));
}
ui->ctcssOn->setChecked(m_settings.m_ctcssOn);
ui->audioMute->setChecked(m_settings.m_audioMute);
ui->ctcss->setCurrentIndex(m_settings.m_ctcssIndex);
blockApplySettings(false);
}
void TCPSrcGUI::resetToDefaults()
{
blockApplySettings(true);
ui->sampleFormat->setCurrentIndex(0);
ui->sampleRate->setText("48000");
ui->rfBandwidth->setText("32000");
ui->tcpPort->setText("9999");
ui->spectrumGUI->resetToDefaults();
ui->boost->setValue(1);
blockApplySettings(false);
applySettings();
}
bool AMDemodGUI::handleMessage(const Message& message)
{
if (AMDemod::MsgConfigureAMDemod::match(message))
{
qDebug("AMDemodGUI::handleMessage: AMDemod::MsgConfigureAMDemod");
const AMDemod::MsgConfigureAMDemod& cfg = (AMDemod::MsgConfigureAMDemod&) message;
m_settings = cfg.getSettings();
blockApplySettings(true);
displaySettings();
blockApplySettings(false);
return true;
}
return false;
}
void DSDDemodGUI::resetToDefaults()
{
blockApplySettings(true);
ui->rfBW->setValue(100); // x100 Hz
ui->demodGain->setValue(100); // 100ths
ui->fmDeviation->setValue(50); // x100 Hz
ui->volume->setValue(20); // /10.0
ui->baudRate->setCurrentIndex(DSDDemodBaudRates::getDefaultRateIndex());
ui->squelchGate->setValue(5);
ui->squelch->setValue(-40);
ui->deltaFrequency->setValue(0);
blockApplySettings(false);
applySettings();
}
bool AMDemodGUI::deserialize(const QByteArray& data)
{
SimpleDeserializer d(data);
if(!d.isValid())
{
resetToDefaults();
return false;
}
if(d.getVersion() == 1)
{
QByteArray bytetmp;
quint32 u32tmp;
qint32 tmp;
blockApplySettings(true);
m_channelMarker.blockSignals(true);
d.readS32(1, &tmp, 0);
m_channelMarker.setCenterFrequency(tmp);
d.readS32(2, &tmp, 4);
ui->rfBW->setValue(tmp);
d.readS32(3, &tmp, 3);
//ui->afBW->setValue(tmp);
d.readS32(4, &tmp, 20);
ui->volume->setValue(tmp);
d.readS32(5, &tmp, -40);
ui->squelch->setValue(tmp);
if(d.readU32(7, &u32tmp))
{
m_channelMarker.setColor(u32tmp);
}
blockApplySettings(false);
m_channelMarker.blockSignals(false);
applySettings();
return true;
}
else
{
resetToDefaults();
return false;
}
}
void SDRdaemonSourceGui::displaySettings()
{
blockApplySettings(true);
ui->centerFrequency->setValue(m_streamCenterFrequency / 1000);
ui->deviceRateText->setText(tr("%1k").arg(m_streamSampleRate / 1000.0));
ui->apiAddress->setText(m_settings.m_apiAddress);
ui->apiPort->setText(tr("%1").arg(m_settings.m_apiPort));
ui->dataPort->setText(tr("%1").arg(m_settings.m_dataPort));
ui->dataAddress->setText(m_settings.m_dataAddress);
ui->dcOffset->setChecked(m_settings.m_dcBlock);
ui->iqImbalance->setChecked(m_settings.m_iqCorrection);
blockApplySettings(false);
}
bool SDRdaemonSinkGui::deserialize(const QByteArray& data)
{
blockApplySettings(true);
if(m_settings.deserialize(data))
{
displaySettings();
blockApplySettings(false);
m_forceSettings = true;
sendSettings();
return true;
}
else
{
blockApplySettings(false);
return false;
}
}
void LimeSDROutputGUI::handleInputMessages()
{
Message* message;
while ((message = m_inputMessageQueue.pop()) != 0)
{
if (DSPSignalNotification::match(*message))
{
qDebug("LimeSDROutputGUI::handleInputMessages: message: %s", message->getIdentifier());
DSPSignalNotification* notif = (DSPSignalNotification*) message;
m_sampleRate = notif->getSampleRate();
m_deviceCenterFrequency = notif->getCenterFrequency();
qDebug("LimeSDROutputGUI::handleInputMessages: DSPSignalNotification: SampleRate: %d, CenterFrequency: %llu", notif->getSampleRate(), notif->getCenterFrequency());
updateSampleRateAndFrequency();
delete message;
}
else if (LimeSDROutput::MsgConfigureLimeSDR::match(*message))
{
const LimeSDROutput::MsgConfigureLimeSDR& cfg = (LimeSDROutput::MsgConfigureLimeSDR&) *message;
m_settings = cfg.getSettings();
displaySettings();
delete message;
}
else if (LimeSDROutput::MsgStartStop::match(*message))
{
LimeSDROutput::MsgStartStop& notif = (LimeSDROutput::MsgStartStop&) *message;
blockApplySettings(true);
ui->startStop->setChecked(notif.getStartStop());
blockApplySettings(false);
delete message;
}
else
{
if (handleMessage(*message)) {
delete message;
}
}
}
}
void SDRdaemonSinkGui::displaySettings()
{
blockApplySettings(true);
ui->centerFrequency->setValue(m_deviceCenterFrequency / 1000);
ui->sampleRate->setValue(m_settings.m_sampleRate);
ui->txDelay->setValue(m_settings.m_txDelay*100);
ui->txDelayText->setText(tr("%1").arg(m_settings.m_txDelay*100));
ui->nbFECBlocks->setValue(m_settings.m_nbFECBlocks);
QString s0 = QString::number(128 + m_settings.m_nbFECBlocks, 'f', 0);
QString s1 = QString::number(m_settings.m_nbFECBlocks, 'f', 0);
ui->nominalNbBlocksText->setText(tr("%1/%2").arg(s0).arg(s1));
ui->deviceIndex->setText(tr("%1").arg(m_settings.m_deviceIndex));
ui->channelIndex->setText(tr("%1").arg(m_settings.m_channelIndex));
ui->apiAddress->setText(m_settings.m_apiAddress);
ui->apiPort->setText(tr("%1").arg(m_settings.m_apiPort));
ui->dataAddress->setText(m_settings.m_dataAddress);
ui->dataPort->setText(tr("%1").arg(m_settings.m_dataPort));
blockApplySettings(false);
}
bool NFMDemodGUI::handleMessage(const Message& message)
{
if (NFMDemod::MsgReportCTCSSFreq::match(message))
{
//qDebug("NFMDemodGUI::handleMessage: NFMDemod::MsgReportCTCSSFreq");
NFMDemod::MsgReportCTCSSFreq& report = (NFMDemod::MsgReportCTCSSFreq&) message;
setCtcssFreq(report.getFrequency());
//qDebug("NFMDemodGUI::handleMessage: MsgReportCTCSSFreq: %f", report.getFrequency());
return true;
}
else if (NFMDemod::MsgConfigureNFMDemod::match(message))
{
qDebug("NFMDemodGUI::handleMessage: NFMDemod::MsgConfigureNFMDemod");
const NFMDemod::MsgConfigureNFMDemod& cfg = (NFMDemod::MsgConfigureNFMDemod&) message;
m_settings = cfg.getSettings();
blockApplySettings(true);
displaySettings();
blockApplySettings(false);
return true;
}
return false;
}
bool SDRdaemonSinkGui::handleMessage(const Message& message)
{
if (SDRdaemonSinkOutput::MsgConfigureSDRdaemonSink::match(message))
{
const SDRdaemonSinkOutput::MsgConfigureSDRdaemonSink& cfg = (SDRdaemonSinkOutput::MsgConfigureSDRdaemonSink&) message;
m_settings = cfg.getSettings();
blockApplySettings(true);
displaySettings();
blockApplySettings(false);
return true;
}
else if (SDRdaemonSinkOutput::MsgStartStop::match(message))
{
SDRdaemonSinkOutput::MsgStartStop& notif = (SDRdaemonSinkOutput::MsgStartStop&) message;
blockApplySettings(true);
ui->startStop->setChecked(notif.getStartStop());
blockApplySettings(false);
return true;
}
else
{
return false;
}
}
bool FileSinkGui::handleMessage(const Message& message)
{
if (FileSinkOutput::MsgConfigureFileSink::match(message))
{
const FileSinkOutput::MsgConfigureFileSink& cfg = (FileSinkOutput::MsgConfigureFileSink&) message;
m_settings = cfg.getSettings();
blockApplySettings(true);
displaySettings();
blockApplySettings(false);
return true;
}
else if (FileSinkOutput::MsgReportFileSinkGeneration::match(message))
{
m_generation = ((FileSinkOutput::MsgReportFileSinkGeneration&)message).getAcquisition();
updateWithGeneration();
return true;
}
else if (FileSinkOutput::MsgReportFileSinkStreamTiming::match(message))
{
m_samplesCount = ((FileSinkOutput::MsgReportFileSinkStreamTiming&)message).getSamplesCount();
updateWithStreamTime();
return true;
}
else if (FileSinkOutput::MsgStartStop::match(message))
{
FileSinkOutput::MsgStartStop& notif = (FileSinkOutput::MsgStartStop&) message;
blockApplySettings(true);
ui->startStop->setChecked(notif.getStartStop());
blockApplySettings(false);
return true;
}
else
{
return false;
}
}
bool LimeSDROutputGUI::handleMessage(const Message& message)
{
if (LimeSDROutput::MsgConfigureLimeSDR::match(message))
{
const LimeSDROutput::MsgConfigureLimeSDR& cfg = (LimeSDROutput::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();
m_settings.m_log2HardInterp = report.getLog2HardDecimInterp();
if (!report.getRxElseTx()) {
m_settings.m_centerFrequency = report.getCenterFrequency();
}
blockApplySettings(true);
displaySettings();
blockApplySettings(false);
return true;
}
else if (DeviceLimeSDRShared::MsgReportClockSourceChange::match(message))
{
DeviceLimeSDRShared::MsgReportClockSourceChange& report = (DeviceLimeSDRShared::MsgReportClockSourceChange&) message;
m_settings.m_extClockFreq = report.getExtClockFeq();
m_settings.m_extClock = report.getExtClock();
blockApplySettings(true);
ui->extClock->setExternalClockFrequency(m_settings.m_extClockFreq);
ui->extClock->setExternalClockActive(m_settings.m_extClock);
blockApplySettings(false);
return true;
}
else if (LimeSDROutput::MsgReportStreamInfo::match(message))
{
LimeSDROutput::MsgReportStreamInfo& report = (LimeSDROutput::MsgReportStreamInfo&) message;
if (report.getSuccess())
{
if (report.getActive()) {
ui->streamStatusLabel->setStyleSheet("QLabel { background-color : green; }");
} else {
ui->streamStatusLabel->setStyleSheet("QLabel { background-color : blue; }");
}
ui->streamLinkRateText->setText(tr("%1 MB/s").arg(QString::number(report.getLinkRate() / 1000000.0f, 'f', 3)));
if (report.getUnderrun() > 0) {
ui->underrunLabel->setStyleSheet("QLabel { background-color : red; }");
} else {
ui->underrunLabel->setStyleSheet("QLabel { background:rgb(79,79,79); }");
}
if (report.getOverrun() > 0) {
ui->overrunLabel->setStyleSheet("QLabel { background-color : red; }");
} else {
ui->overrunLabel->setStyleSheet("QLabel { background:rgb(79,79,79); }");
}
if (report.getDroppedPackets() > 0) {
ui->droppedLabel->setStyleSheet("QLabel { background-color : red; }");
} else {
ui->droppedLabel->setStyleSheet("QLabel { background:rgb(79,79,79); }");
}
ui->fifoBar->setMaximum(report.getFifoSize());
ui->fifoBar->setValue(report.getFifoFilledCount());
ui->fifoBar->setToolTip(tr("FIFO fill %1/%2 samples").arg(QString::number(report.getFifoFilledCount())).arg(QString::number(report.getFifoSize())));
}
else
{
ui->streamStatusLabel->setStyleSheet("QLabel { background:rgb(79,79,79); }");
}
return true;
}
else if (DeviceLimeSDRShared::MsgReportDeviceInfo::match(message))
{
DeviceLimeSDRShared::MsgReportDeviceInfo& report = (DeviceLimeSDRShared::MsgReportDeviceInfo&) message;
ui->temperatureText->setText(tr("%1C").arg(QString::number(report.getTemperature(), 'f', 0)));
ui->gpioText->setText(tr("%1").arg(report.getGPIOPins(), 2, 16, QChar('0')).toUpper());
return true;
}
return false;
}
void AMDemodGUI::displaySettings()
{
m_channelMarker.blockSignals(true);
m_channelMarker.setCenterFrequency(m_settings.m_inputFrequencyOffset);
m_channelMarker.setBandwidth(m_settings.m_rfBandwidth);
m_channelMarker.setTitle(m_settings.m_title);
m_channelMarker.blockSignals(false);
m_channelMarker.setColor(m_settings.m_rgbColor); // activate signal on the last setting only
setTitleColor(m_settings.m_rgbColor);
setWindowTitle(m_channelMarker.getTitle());
blockApplySettings(true);
ui->deltaFrequency->setValue(m_channelMarker.getCenterFrequency());
int displayValue = m_settings.m_rfBandwidth/100.0;
ui->rfBW->setValue(displayValue);
ui->rfBWText->setText(QString("%1 kHz").arg(displayValue / 10.0, 0, 'f', 1));
ui->volume->setValue(m_settings.m_volume * 10.0);
ui->volumeText->setText(QString("%1").arg(m_settings.m_volume, 0, 'f', 1));
ui->squelch->setValue(m_settings.m_squelch);
ui->squelchText->setText(QString("%1 dB").arg(m_settings.m_squelch));
ui->audioMute->setChecked(m_settings.m_audioMute);
ui->bandpassEnable->setChecked(m_settings.m_bandpassEnable);
ui->pll->setChecked(m_settings.m_pll);
qDebug() << "AMDemodGUI::displaySettings:"
<< " m_pll: " << m_settings.m_pll
<< " m_syncAMOperation: " << m_settings.m_syncAMOperation;
if (m_settings.m_pll)
{
if (m_settings.m_syncAMOperation == AMDemodSettings::SyncAMLSB)
{
m_samUSB = false;
ui->ssb->setChecked(true);
ui->ssb->setIcon(m_iconDSBLSB);
}
else if (m_settings.m_syncAMOperation == AMDemodSettings::SyncAMUSB)
{
m_samUSB = true;
ui->ssb->setChecked(true);
ui->ssb->setIcon(m_iconDSBUSB);
}
else
{
ui->ssb->setChecked(false);
}
}
else
{
ui->ssb->setChecked(false);
ui->ssb->setIcon(m_iconDSBUSB);
}
blockApplySettings(false);
}
bool SDRdaemonSourceGui::handleMessage(const Message& 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();
return true;
}
else if (SDRdaemonSourceInput::MsgReportSDRdaemonSourceStreamData::match(message))
{
m_startingTimeStampms = ((SDRdaemonSourceInput::MsgReportSDRdaemonSourceStreamData&)message).get_tv_msec();
qDebug() << "SDRdaemonSourceGui::handleMessage: SDRdaemonSourceInput::MsgReportSDRdaemonSourceStreamData: "
<< " : " << m_startingTimeStampms << " ms";
updateWithStreamTime();
return true;
}
else if (SDRdaemonSourceInput::MsgReportSDRdaemonSourceStreamTiming::match(message))
{
m_startingTimeStampms = ((SDRdaemonSourceInput::MsgReportSDRdaemonSourceStreamTiming&)message).get_tv_msec();
m_framesDecodingStatus = ((SDRdaemonSourceInput::MsgReportSDRdaemonSourceStreamTiming&)message).getFramesDecodingStatus();
m_allBlocksReceived = ((SDRdaemonSourceInput::MsgReportSDRdaemonSourceStreamTiming&)message).allBlocksReceived();
m_bufferLengthInSecs = ((SDRdaemonSourceInput::MsgReportSDRdaemonSourceStreamTiming&)message).getBufferLengthInSecs();
m_bufferGauge = ((SDRdaemonSourceInput::MsgReportSDRdaemonSourceStreamTiming&)message).getBufferGauge();
m_minNbBlocks = ((SDRdaemonSourceInput::MsgReportSDRdaemonSourceStreamTiming&)message).getMinNbBlocks();
m_minNbOriginalBlocks = ((SDRdaemonSourceInput::MsgReportSDRdaemonSourceStreamTiming&)message).getMinNbOriginalBlocks();
m_maxNbRecovery = ((SDRdaemonSourceInput::MsgReportSDRdaemonSourceStreamTiming&)message).getMaxNbRecovery();
m_avgNbBlocks = ((SDRdaemonSourceInput::MsgReportSDRdaemonSourceStreamTiming&)message).getAvgNbBlocks();
m_avgNbOriginalBlocks = ((SDRdaemonSourceInput::MsgReportSDRdaemonSourceStreamTiming&)message).getAvgNbOriginalBlocks();
m_avgNbRecovery = ((SDRdaemonSourceInput::MsgReportSDRdaemonSourceStreamTiming&)message).getAvgNbRecovery();
m_nbOriginalBlocks = ((SDRdaemonSourceInput::MsgReportSDRdaemonSourceStreamTiming&)message).getNbOriginalBlocksPerFrame();
m_sampleBits = ((SDRdaemonSourceInput::MsgReportSDRdaemonSourceStreamTiming&)message).getSampleBits();
m_sampleBytes = ((SDRdaemonSourceInput::MsgReportSDRdaemonSourceStreamTiming&)message).getSampleBytes();
int nbFECBlocks = ((SDRdaemonSourceInput::MsgReportSDRdaemonSourceStreamTiming&)message).getNbFECBlocksPerFrame();
if (m_nbFECBlocks != nbFECBlocks) {
m_nbFECBlocks = nbFECBlocks;
}
updateWithStreamTime();
return true;
}
else if (SDRdaemonSourceInput::MsgStartStop::match(message))
{
SDRdaemonSourceInput::MsgStartStop& notif = (SDRdaemonSourceInput::MsgStartStop&) message;
blockApplySettings(true);
ui->startStop->setChecked(notif.getStartStop());
blockApplySettings(false);
return true;
}
else
{
return false;
}
}
void AMDemodGUI::leaveEvent(QEvent*)
{
blockApplySettings(true);
m_channelMarker.setHighlighted(false);
blockApplySettings(false);
}
void DSDDemodGUI::enterEvent(QEvent*)
{
blockApplySettings(true);
m_channelMarker.setHighlighted(true);
blockApplySettings(false);
}
bool DSDDemodGUI::deserialize(const QByteArray& data)
{
SimpleDeserializer d(data);
if (!d.isValid())
{
resetToDefaults();
return false;
}
if (d.getVersion() == 1)
{
QByteArray bytetmp;
quint32 u32tmp;
qint32 tmp;
bool boolTmp;
blockApplySettings(true);
m_channelMarker.blockSignals(true);
d.readS32(1, &tmp, 0);
m_channelMarker.setCenterFrequency(tmp);
d.readS32(2, &tmp, 4);
ui->rfBW->setValue(tmp);
d.readS32(3, &tmp, 3);
ui->demodGain->setValue(tmp);
d.readS32(4, &tmp, 20);
ui->fmDeviation->setValue(tmp);
d.readS32(5, &tmp, -40);
ui->squelch->setValue(tmp);
if(d.readU32(7, &u32tmp))
{
m_channelMarker.setColor(u32tmp);
}
d.readS32(8, &tmp, 5);
ui->squelchGate->setValue(tmp);
d.readS32(9, &tmp, 20);
ui->volume->setValue(tmp);
d.readBlob(10, &bytetmp);
ui->scopeGUI->deserialize(bytetmp);
d.readS32(11, &tmp, 20);
ui->baudRate->setCurrentIndex(tmp);
d.readBool(12, &m_enableCosineFiltering, false);
d.readBool(13, &m_syncOrConstellation, false);
d.readBool(14, &m_slot1On, false);
d.readBool(15, &m_slot2On, false);
d.readBool(16, &m_tdmaStereo, false);
blockApplySettings(false);
m_channelMarker.blockSignals(false);
updateMyPosition(); // we do it also here to be able to refresh with latest settings
applySettings();
return true;
}
else
{
resetToDefaults();
return false;
}
}
bool DATVDemodGUI::deserialize(const QByteArray& arrData)
{
SimpleDeserializer d(arrData);
if (!d.isValid())
{
resetToDefaults();
return false;
}
if (d.getVersion() == 1)
{
QByteArray bytetmp;
uint32_t u32tmp;
qint64 i64tmp;
int tmp;
bool booltmp;
blockApplySettings(true);
m_objChannelMarker.blockSignals(true);
d.readS32(1, &tmp, 0);
m_objChannelMarker.setCenterFrequency(tmp);
ui->deltaFrequency->setValue(tmp);
if (d.readU32(2, &u32tmp))
{
m_objChannelMarker.setColor(u32tmp);
}
else
{
m_objChannelMarker.setColor(Qt::magenta);
}
d.readBool(3, &booltmp, false);
ui->chkAllowDrift->setChecked(booltmp);
d.readBool(4, &booltmp, false);
ui->chkFastlock->setChecked(booltmp);
d.readS32(5, &tmp, false);
ui->cmbFilter->setCurrentIndex(tmp);
displayRRCParameters((tmp==2));
d.readBool(6, &booltmp, false);
ui->chkHardMetric->setChecked(booltmp);
d.readS32(7, &tmp, false);
ui->spiRollOff->setValue(tmp);
d.readBool(8, &booltmp, false);
ui->chkViterbi->setChecked(booltmp);
d.readS32(9, &tmp, 0);
ui->cmbFEC->setCurrentIndex(tmp);
d.readS32(10, &tmp, 0);
ui->cmbModulation->setCurrentIndex(tmp);
d.readS32(11, &tmp, 0);
ui->cmbStandard->setCurrentIndex(tmp);
d.readS32(12, &tmp, 0);
ui->spiNotchFilters->setValue(tmp);
d.readS64(13, &i64tmp, 5120000);
ui->rfBandwidth->setValue(i64tmp);
d.readS32(14, &tmp, 250000);
ui->spiSymbolRate->setValue(tmp);
d.readS32(15, &tmp, false);
ui->spiExcursion->setValue(tmp);
blockApplySettings(false);
m_objChannelMarker.blockSignals(false);
applySettings();
return true;
}
else
{
resetToDefaults();
return false;
}
}
bool TCPSrcGUI::deserialize(const QByteArray& data)
{
SimpleDeserializer d(data);
if (!d.isValid())
{
resetToDefaults();
return false;
}
if (d.getVersion() == 1)
{
QByteArray bytetmp;
qint32 s32tmp;
Real realtmp;
blockApplySettings(true);
m_channelMarker.blockSignals(true);
d.readBlob(1, &bytetmp);
restoreState(bytetmp);
d.readS32(2, &s32tmp, 0);
m_channelMarker.setCenterFrequency(s32tmp);
d.readS32(3, &s32tmp, TCPSrc::FormatSSB);
switch(s32tmp) {
case TCPSrc::FormatSSB:
ui->sampleFormat->setCurrentIndex(0);
break;
case TCPSrc::FormatNFM:
ui->sampleFormat->setCurrentIndex(1);
break;
case TCPSrc::FormatS16LE:
ui->sampleFormat->setCurrentIndex(2);
break;
default:
ui->sampleFormat->setCurrentIndex(0);
break;
}
d.readReal(4, &realtmp, 48000);
ui->sampleRate->setText(QString("%1").arg(realtmp, 0));
d.readReal(5, &realtmp, 32000);
ui->rfBandwidth->setText(QString("%1").arg(realtmp, 0));
d.readS32(6, &s32tmp, 9999);
ui->tcpPort->setText(QString("%1").arg(s32tmp));
d.readBlob(7, &bytetmp);
ui->spectrumGUI->deserialize(bytetmp);
d.readS32(8, &s32tmp, 1);
ui->boost->setValue(s32tmp);
d.readS32(9, &s32tmp, 0);
m_channelMarker.setCenterFrequency(s32tmp);
blockApplySettings(false);
m_channelMarker.blockSignals(false);
applySettings();
return true;
}
else
{
resetToDefaults();
return false;
}
}
NFMDemodGUI::NFMDemodGUI(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, BasebandSampleSink *rxChannel, QWidget* parent) :
RollupWidget(parent),
ui(new Ui::NFMDemodGUI),
m_pluginAPI(pluginAPI),
m_deviceUISet(deviceUISet),
m_channelMarker(this),
m_basicSettingsShown(false),
m_doApplySettings(true),
m_squelchOpen(false),
m_tickCount(0)
{
ui->setupUi(this);
setAttribute(Qt::WA_DeleteOnClose, true);
connect(this, SIGNAL(widgetRolled(QWidget*,bool)), this, SLOT(onWidgetRolled(QWidget*,bool)));
connect(this, SIGNAL(customContextMenuRequested(const QPoint &)), this, SLOT(onMenuDialogCalled(const QPoint &)));
m_nfmDemod = reinterpret_cast<NFMDemod*>(rxChannel); //new NFMDemod(m_deviceUISet->m_deviceSourceAPI);
m_nfmDemod->setMessageQueueToGUI(getInputMessageQueue());
connect(&MainWindow::getInstance()->getMasterTimer(), SIGNAL(timeout()), this, SLOT(tick()));
CRightClickEnabler *audioMuteRightClickEnabler = new CRightClickEnabler(ui->audioMute);
connect(audioMuteRightClickEnabler, SIGNAL(rightClick(const QPoint &)), this, SLOT(audioSelect()));
blockApplySettings(true);
ui->rfBW->clear();
for (int i = 0; i < NFMDemodSettings::m_nbRfBW; i++) {
ui->rfBW->addItem(QString("%1").arg(NFMDemodSettings::getRFBW(i) / 1000.0, 0, 'f', 2));
}
int ctcss_nbTones;
const Real *ctcss_tones = m_nfmDemod->getCtcssToneSet(ctcss_nbTones);
ui->ctcss->addItem("--");
for (int i=0; i<ctcss_nbTones; i++)
{
ui->ctcss->addItem(QString("%1").arg(ctcss_tones[i]));
}
blockApplySettings(false);
ui->audioMute->setStyleSheet("QToolButton { background:rgb(79,79,79); }"); // squelch closed
ui->deltaFrequencyLabel->setText(QString("%1f").arg(QChar(0x94, 0x03)));
ui->deltaFrequency->setColorMapper(ColorMapper(ColorMapper::GrayGold));
ui->deltaFrequency->setValueRange(false, 7, -9999999, 9999999);
ui->channelPowerMeter->setColorTheme(LevelMeterSignalDB::ColorGreenAndBlue);
m_channelMarker.blockSignals(true);
m_channelMarker.setColor(Qt::red);
m_channelMarker.setBandwidth(5000);
m_channelMarker.setCenterFrequency(0);
m_channelMarker.setTitle("NFM Demodulator");
m_channelMarker.blockSignals(false);
m_channelMarker.setVisible(true); // activate signal on the last setting only
m_settings.setChannelMarker(&m_channelMarker);
m_deviceUISet->registerRxChannelInstance(NFMDemod::m_channelIdURI, this);
m_deviceUISet->addChannelMarker(&m_channelMarker);
m_deviceUISet->addRollupWidget(this);
connect(&m_channelMarker, SIGNAL(changedByCursor()), this, SLOT(channelMarkerChangedByCursor()));
connect(&m_channelMarker, SIGNAL(highlightedByCursor()), this, SLOT(channelMarkerHighlightedByCursor()));
QChar delta = QChar(0x94, 0x03);
ui->deltaSquelch->setText(delta);
connect(getInputMessageQueue(), SIGNAL(messageEnqueued()), this, SLOT(handleInputMessages()));
displaySettings();
applySettings(true);
}
