#include "ssbdemodgui.h" #include "ssbdemodgui.h" #include #include "device/deviceuiset.h" #include #include #include "ui_ssbdemodgui.h" #include "dsp/spectrumvis.h" #include "gui/glspectrum.h" #include "plugin/pluginapi.h" #include "util/simpleserializer.h" #include "util/db.h" #include "gui/basicchannelsettingswidget.h" #include "dsp/dspengine.h" #include "mainwindow.h" #include "ssbdemod.h" const QString SSBDemodGUI::m_channelID = "de.maintech.sdrangelove.channel.ssb"; SSBDemodGUI* SSBDemodGUI::create(PluginAPI* pluginAPI, DeviceUISet *deviceUISet) { SSBDemodGUI* gui = new SSBDemodGUI(pluginAPI, deviceUISet); return gui; } void SSBDemodGUI::destroy() { delete this; } void SSBDemodGUI::setName(const QString& name) { setObjectName(name); } QString SSBDemodGUI::getName() const { return objectName(); } qint64 SSBDemodGUI::getCenterFrequency() const { return m_channelMarker.getCenterFrequency(); } void SSBDemodGUI::setCenterFrequency(qint64 centerFrequency) { m_channelMarker.setCenterFrequency(centerFrequency); m_settings.m_inputFrequencyOffset = m_channelMarker.getCenterFrequency(); applySettings(); } void SSBDemodGUI::resetToDefaults() { m_settings.resetToDefaults(); } QByteArray SSBDemodGUI::serialize() const { return m_settings.serialize(); } bool SSBDemodGUI::deserialize(const QByteArray& data) { if(m_settings.deserialize(data)) { displaySettings(); applySettings(true); // will have true return true; } else { m_settings.resetToDefaults(); displaySettings(); applySettings(true); // will have true return false; } } bool SSBDemodGUI::handleMessage(const Message& message __attribute__((unused))) { return false; } void SSBDemodGUI::viewChanged() { applySettings(); } void SSBDemodGUI::on_audioBinaural_toggled(bool binaural) { m_audioBinaural = binaural; m_settings.m_audioBinaural = binaural; applySettings(); } void SSBDemodGUI::on_audioFlipChannels_toggled(bool flip) { m_audioFlipChannels = flip; m_settings.m_audioFlipChannels = flip; applySettings(); } void SSBDemodGUI::on_dsb_toggled(bool dsb __attribute__((unused))) { applyBandwidths(); } void SSBDemodGUI::on_deltaFrequency_changed(qint64 value) { m_channelMarker.setCenterFrequency(value); m_settings.m_inputFrequencyOffset = m_channelMarker.getCenterFrequency(); applySettings(); } void SSBDemodGUI::on_BW_valueChanged(int value __attribute__((unused))) { applyBandwidths(); } void SSBDemodGUI::on_lowCut_valueChanged(int value __attribute__((unused))) { applyBandwidths(); } void SSBDemodGUI::on_volume_valueChanged(int value) { ui->volumeText->setText(QString("%1").arg(value / 10.0, 0, 'f', 1)); m_settings.m_volume = value / 10.0; applySettings(); } void SSBDemodGUI::on_agc_toggled(bool checked) { m_settings.m_agc = checked; applySettings(); } void SSBDemodGUI::on_agcClamping_toggled(bool checked) { m_settings.m_agcClamping = checked; applySettings(); } void SSBDemodGUI::on_agcTimeLog2_valueChanged(int value) { QString s = QString::number((1<agcTimeText->setText(s); m_settings.m_agcTimeLog2 = value; applySettings(); } void SSBDemodGUI::on_agcPowerThreshold_valueChanged(int value) { displayAGCPowerThreshold(value); m_settings.m_agcPowerThreshold = value; applySettings(); } void SSBDemodGUI::on_agcThresholdGate_valueChanged(int value) { QString s = QString::number(value, 'f', 0); ui->agcThresholdGateText->setText(s); m_settings.m_agcThresholdGate = value; applySettings(); } void SSBDemodGUI::on_audioMute_toggled(bool checked) { m_audioMute = checked; m_settings.m_audioMute = checked; applySettings(); } void SSBDemodGUI::on_spanLog2_valueChanged(int value) { if ((value < 1) || (value > 5)) { return; } applyBandwidths(); } void SSBDemodGUI::onWidgetRolled(QWidget* widget __attribute__((unused)), bool rollDown __attribute__((unused))) { /* if((widget == ui->spectrumContainer) && (m_ssbDemod != NULL)) m_ssbDemod->setSpectrum(m_threadedSampleSink->getMessageQueue(), rollDown); */ } void SSBDemodGUI::onMenuDoubleClicked() { if(!m_basicSettingsShown) { m_basicSettingsShown = true; BasicChannelSettingsWidget* bcsw = new BasicChannelSettingsWidget(&m_channelMarker, this); bcsw->show(); } } SSBDemodGUI::SSBDemodGUI(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, QWidget* parent) : RollupWidget(parent), ui(new Ui::SSBDemodGUI), m_pluginAPI(pluginAPI), m_deviceUISet(deviceUISet), m_channelMarker(this), m_basicSettingsShown(false), m_doApplySettings(true), m_spectrumRate(6000), m_audioBinaural(false), m_audioFlipChannels(false), m_audioMute(false), m_squelchOpen(false) { ui->setupUi(this); setAttribute(Qt::WA_DeleteOnClose, true); connect(this, SIGNAL(widgetRolled(QWidget*,bool)), this, SLOT(onWidgetRolled(QWidget*,bool))); connect(this, SIGNAL(menuDoubleClickEvent()), this, SLOT(onMenuDoubleClicked())); m_spectrumVis = new SpectrumVis(ui->glSpectrum); m_ssbDemod = new SSBDemod(m_deviceUISet->m_deviceSourceAPI); m_ssbDemod->setMessageQueueToGUI(getInputMessageQueue()); m_ssbDemod->setSampleSink(m_spectrumVis); 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); ui->glSpectrum->setCenterFrequency(m_spectrumRate/2); ui->glSpectrum->setSampleRate(m_spectrumRate); ui->glSpectrum->setDisplayWaterfall(true); ui->glSpectrum->setDisplayMaxHold(true); ui->glSpectrum->setSsbSpectrum(true); ui->glSpectrum->connectTimer(MainWindow::getInstance()->getMasterTimer()); connect(&MainWindow::getInstance()->getMasterTimer(), SIGNAL(timeout()), this, SLOT(tick())); m_channelMarker.setColor(Qt::green); m_channelMarker.setBandwidth(6000); m_channelMarker.setCenterFrequency(0); m_channelMarker.setTitle("SSB Demodulator"); m_channelMarker.setUDPAddress("127.0.0.1"); m_channelMarker.setUDPSendPort(9999); m_channelMarker.setVisible(true); setTitleColor(m_channelMarker.getColor()); m_settings.setChannelMarker(&m_channelMarker); m_settings.setSpectrumGUI(ui->spectrumGUI); connect(&m_channelMarker, SIGNAL(changed()), this, SLOT(viewChanged())); m_deviceUISet->registerRxChannelInstance(m_channelID, this); m_deviceUISet->addChannelMarker(&m_channelMarker); m_deviceUISet->addRollupWidget(this); ui->spectrumGUI->setBuddies(m_spectrumVis->getInputMessageQueue(), m_spectrumVis, ui->glSpectrum); displaySettings(); applyBandwidths(true); // does applySettings(true) } SSBDemodGUI::~SSBDemodGUI() { m_deviceUISet->removeRxChannelInstance(this); delete m_ssbDemod; delete m_spectrumVis; delete ui; } bool SSBDemodGUI::blockApplySettings(bool block) { bool ret = !m_doApplySettings; m_doApplySettings = !block; return ret; } void SSBDemodGUI::applySettings(bool force) { if (m_doApplySettings) { setTitleColor(m_channelMarker.getColor()); ui->deltaFrequency->setValue(m_channelMarker.getCenterFrequency()); SSBDemod::MsgConfigureChannelizer* channelConfigMsg = SSBDemod::MsgConfigureChannelizer::create( 48000, m_channelMarker.getCenterFrequency()); m_ssbDemod->getInputMessageQueue()->push(channelConfigMsg); SSBDemod::MsgConfigureSSBDemod* message = SSBDemod::MsgConfigureSSBDemod::create( m_settings, force); m_ssbDemod->getInputMessageQueue()->push(message); } } void SSBDemodGUI::applyBandwidths(bool force) { bool dsb = ui->dsb->isChecked(); int spanLog2 = ui->spanLog2->value(); m_spectrumRate = 48000 / (1<BW->value(); int lw = ui->lowCut->value(); int bwMax = 480/(1< bwMax ? bwMax : bw; if (bw < 0) { lw = lw < bw+1 ? bw+1 : lw < 0 ? lw : 0; } else if (bw > 0) { lw = lw > bw-1 ? bw-1 : lw < 0 ? 0 : lw; } else { lw = 0; } if (dsb) { bw = bw < 0 ? -bw : bw; lw = 0; } QString spanStr = QString::number(bwMax/10.0, 'f', 1); QString bwStr = QString::number(bw/10.0, 'f', 1); QString lwStr = QString::number(lw/10.0, 'f', 1); if (dsb) { ui->BWText->setText(tr("%1%2k").arg(QChar(0xB1, 0x00)).arg(bwStr)); ui->spanText->setText(tr("%1%2k").arg(QChar(0xB1, 0x00)).arg(spanStr)); ui->glSpectrum->setCenterFrequency(0); ui->glSpectrum->setSampleRate(2*m_spectrumRate); ui->glSpectrum->setSsbSpectrum(false); ui->glSpectrum->setLsbDisplay(false); } else { ui->BWText->setText(tr("%1k").arg(bwStr)); ui->spanText->setText(tr("%1k").arg(spanStr)); ui->glSpectrum->setCenterFrequency(m_spectrumRate/2); ui->glSpectrum->setSampleRate(m_spectrumRate); ui->glSpectrum->setSsbSpectrum(true); ui->glSpectrum->setLsbDisplay(bw < 0); } ui->lowCutText->setText(tr("%1k").arg(lwStr)); ui->BW->blockSignals(true); ui->lowCut->blockSignals(true); ui->BW->setMaximum(bwMax); ui->BW->setMinimum(dsb ? 0 : -bwMax); ui->BW->setValue(bw); ui->lowCut->setMaximum(dsb ? 0 : bwMax); ui->lowCut->setMinimum(dsb ? 0 : -bwMax); ui->lowCut->setValue(lw); ui->lowCut->blockSignals(false); ui->BW->blockSignals(false); m_settings.m_dsb = dsb; m_settings.m_spanLog2 = spanLog2; m_settings.m_rfBandwidth = bw * 100; m_settings.m_lowCutoff = lw * 100; applySettings(force); bool wasBlocked = blockApplySettings(true); m_channelMarker.setBandwidth(bw * 200); m_channelMarker.setSidebands(dsb ? ChannelMarker::dsb : bw < 0 ? ChannelMarker::lsb : ChannelMarker::usb); blockApplySettings(wasBlocked); } void SSBDemodGUI::displaySettings() { bool applySettingsWereBlocked = blockApplySettings(true); m_channelMarker.blockSignals(true); m_channelMarker.setCenterFrequency(m_settings.m_inputFrequencyOffset); m_channelMarker.setBandwidth(m_settings.m_rfBandwidth * 2); m_channelMarker.setLowCutoff(m_settings.m_lowCutoff); m_channelMarker.setColor(m_settings.m_rgbColor); setTitleColor(m_settings.m_rgbColor); if (m_settings.m_dsb) { m_channelMarker.setSidebands(ChannelMarker::dsb); } else { if (m_settings.m_rfBandwidth < 0) { m_channelMarker.setSidebands(ChannelMarker::lsb); } else { m_channelMarker.setSidebands(ChannelMarker::usb); } } m_channelMarker.blockSignals(false); setWindowTitle(m_channelMarker.getTitle()); ui->agc->setChecked(m_settings.m_agc); ui->agcClamping->setChecked(m_settings.m_agcClamping); ui->audioBinaural->setChecked(m_settings.m_audioBinaural); ui->audioFlipChannels->setChecked(m_settings.m_audioFlipChannels); ui->audioMute->setChecked(m_settings.m_audioMute); ui->deltaFrequency->setValue(m_channelMarker.getCenterFrequency()); // Prevent uncontrolled triggering of applyBandwidths ui->spanLog2->blockSignals(true); ui->dsb->blockSignals(true); ui->BW->blockSignals(true); ui->dsb->setChecked(m_settings.m_dsb); ui->spanLog2->setValue(m_settings.m_spanLog2); ui->BW->setValue(m_settings.m_rfBandwidth / 100.0); QString s = QString::number(m_settings.m_rfBandwidth/1000.0, 'f', 1); if (m_settings.m_dsb) { ui->BWText->setText(tr("%1%2k").arg(QChar(0xB1, 0x00)).arg(s)); } else { ui->BWText->setText(tr("%1k").arg(s)); } ui->spanLog2->blockSignals(false); ui->dsb->blockSignals(false); ui->BW->blockSignals(false); // The only one of the four signals triggering applyBandwidths will trigger it once only with all other values // set correctly and therefore validate the settings and apply them to dependent widgets ui->lowCut->setValue(m_settings.m_lowCutoff / 100.0); ui->lowCutText->setText(tr("%1k").arg(m_settings.m_lowCutoff / 1000.0)); ui->volume->setValue(m_settings.m_volume * 10.0); ui->volumeText->setText(QString("%1").arg(m_settings.m_volume, 0, 'f', 1)); ui->agcTimeLog2->setValue(m_settings.m_agcTimeLog2); s = QString::number((1<agcTimeLog2->value()), 'f', 0); ui->agcTimeText->setText(s); ui->agcPowerThreshold->setValue(m_settings.m_agcPowerThreshold); displayAGCPowerThreshold(ui->agcPowerThreshold->value()); ui->agcThresholdGate->setValue(m_settings.m_agcThresholdGate); s = QString::number(ui->agcThresholdGate->value(), 'f', 0); ui->agcThresholdGateText->setText(s); blockApplySettings(applySettingsWereBlocked); } void SSBDemodGUI::displayUDPAddress() { //TODO: ui->copyAudioToUDP->setToolTip(QString("Copy audio output to UDP %1:%2").arg(m_channelMarker.getUDPAddress()).arg(m_channelMarker.getUDPSendPort())); } void SSBDemodGUI::displayAGCPowerThreshold(int value) { if (value == -99) { ui->agcPowerThresholdText->setText("---"); } else { QString s = QString::number(value, 'f', 0); ui->agcPowerThresholdText->setText(s); } } void SSBDemodGUI::leaveEvent(QEvent*) { bool applySettingsWereBlocked = blockApplySettings(true); m_channelMarker.setHighlighted(false); blockApplySettings(applySettingsWereBlocked); } void SSBDemodGUI::enterEvent(QEvent*) { bool applySettingsWereBlocked = blockApplySettings(true); m_channelMarker.setHighlighted(true); blockApplySettings(applySettingsWereBlocked); } void SSBDemodGUI::tick() { double magsqAvg, magsqPeak; int nbMagsqSamples; m_ssbDemod->getMagSqLevels(magsqAvg, magsqPeak, nbMagsqSamples); double powDbAvg = CalcDb::dbPower(magsqAvg); double powDbPeak = CalcDb::dbPower(magsqPeak); ui->channelPowerMeter->levelChanged( (100.0f + powDbAvg) / 100.0f, (100.0f + powDbPeak) / 100.0f, nbMagsqSamples); if (m_tickCount % 4 == 0) { ui->channelPower->setText(tr("%1 dB").arg(powDbAvg, 0, 'f', 1)); } bool squelchOpen = m_ssbDemod->getAudioActive(); if (squelchOpen != m_squelchOpen) { if (squelchOpen) { ui->audioMute->setStyleSheet("QToolButton { background-color : green; }"); } else { ui->audioMute->setStyleSheet("QToolButton { background:rgb(79,79,79); }"); } m_squelchOpen = squelchOpen; } m_tickCount++; }