Example #1
0
void FCDProInput::applySettings(const FCDProSettings& settings, bool force)
{
	bool forwardChange = false;
    QList<QString> reverseAPIKeys;

    if (force || (m_settings.m_centerFrequency != settings.m_centerFrequency)) {
		reverseAPIKeys.append("centerFrequency");
	}
    if (force || (m_settings.m_transverterMode != settings.m_transverterMode)) {
		reverseAPIKeys.append("transverterMode");
	}
    if (force || (m_settings.m_transverterDeltaFrequency != settings.m_transverterDeltaFrequency)) {
		reverseAPIKeys.append("transverterDeltaFrequency");
	}

	if (force || (m_settings.m_centerFrequency != settings.m_centerFrequency)
            || (m_settings.m_transverterMode != settings.m_transverterMode)
            || (m_settings.m_transverterDeltaFrequency != settings.m_transverterDeltaFrequency))
	{
        qint64 deviceCenterFrequency = settings.m_centerFrequency;
        deviceCenterFrequency -= settings.m_transverterMode ? settings.m_transverterDeltaFrequency : 0;
        deviceCenterFrequency = deviceCenterFrequency < 0 ? 0 : deviceCenterFrequency;

        if (m_dev != 0)
        {
            set_center_freq((double) deviceCenterFrequency);
        }

        qDebug() << "FCDProInput::applySettings: center freq: " << settings.m_centerFrequency << " Hz"
                << " device center freq: " << deviceCenterFrequency << " Hz";

		forwardChange = (m_settings.m_centerFrequency != settings.m_centerFrequency) || force;

		m_settings.m_centerFrequency = settings.m_centerFrequency;
	}

	if ((m_settings.m_lnaGainIndex != settings.m_lnaGainIndex) || force)
	{
		reverseAPIKeys.append("lnaGainIndex");

		if (m_dev != 0) {
			set_lnaGain(settings.m_lnaGainIndex);
		}
	}

	if ((m_settings.m_rfFilterIndex != settings.m_rfFilterIndex) || force)
	{
		reverseAPIKeys.append("rfFilterIndex");

		if (m_dev != 0) {
			set_rfFilter(settings.m_rfFilterIndex);
		}
	}

	if ((m_settings.m_lnaEnhanceIndex != settings.m_lnaEnhanceIndex) || force)
	{
		reverseAPIKeys.append("lnaEnhanceIndex");

		if (m_dev != 0) {
			set_lnaEnhance(settings.m_lnaEnhanceIndex);
		}
	}

	if ((m_settings.m_bandIndex != settings.m_bandIndex) || force)
	{
		reverseAPIKeys.append("bandIndex");

		if (m_dev != 0) {
			set_band(settings.m_bandIndex);
		}
	}

	if ((m_settings.m_mixerGainIndex != settings.m_mixerGainIndex) || force)
	{
		reverseAPIKeys.append("mixerGainIndex");

		if (m_dev != 0) {
			set_mixerGain(settings.m_mixerGainIndex);
		}
	}

	if ((m_settings.m_mixerFilterIndex != settings.m_mixerFilterIndex) || force)
	{
		reverseAPIKeys.append("mixerFilterIndex");

		if (m_dev != 0) {
			set_mixerFilter(settings.m_mixerFilterIndex);
		}
	}

	if ((m_settings.m_biasCurrentIndex != settings.m_biasCurrentIndex) || force)
	{
		reverseAPIKeys.append("biasCurrentIndex");

		if (m_dev != 0) {
			set_biasCurrent(settings.m_biasCurrentIndex);
		}
	}

	if ((m_settings.m_modeIndex != settings.m_modeIndex) || force)
	{
		reverseAPIKeys.append("modeIndex");

		if (m_dev != 0) {
			set_mode(settings.m_modeIndex);
		}
	}

	if ((m_settings.m_gain1Index != settings.m_gain1Index) || force)
	{
		reverseAPIKeys.append("gain1Index");

		if (m_dev != 0) {
			set_gain1(settings.m_gain1Index);
		}
	}

	if ((m_settings.m_rcFilterIndex != settings.m_rcFilterIndex) || force)
	{
		reverseAPIKeys.append("rcFilterIndex");

		if (m_dev != 0) {
			set_rcFilter(settings.m_rcFilterIndex);
		}
	}

	if ((m_settings.m_gain2Index != settings.m_gain2Index) || force)
	{
		reverseAPIKeys.append("gain2Index");

		if (m_dev != 0) {
			set_gain2(settings.m_gain2Index);
		}
	}

	if ((m_settings.m_gain3Index != settings.m_gain3Index) || force)
	{
		reverseAPIKeys.append("gain3Index");

		if (m_dev != 0) {
			set_gain3(settings.m_gain3Index);
		}
	}

	if ((m_settings.m_gain4Index != settings.m_gain4Index) || force)
	{
		reverseAPIKeys.append("gain4Index");

		if (m_dev != 0) {
			set_gain4(settings.m_gain4Index);
		}
	}

	if ((m_settings.m_ifFilterIndex != settings.m_ifFilterIndex) || force)
	{
		reverseAPIKeys.append("ifFilterIndex");

		if (m_dev != 0) {
			set_ifFilter(settings.m_ifFilterIndex);
		}
	}

	if ((m_settings.m_gain5Index != settings.m_gain5Index) || force)
	{
		reverseAPIKeys.append("gain5Index");

		if (m_dev != 0) {
			set_gain5(settings.m_gain5Index);
		}
	}

	if ((m_settings.m_gain6Index != settings.m_gain6Index) || force)
	{
		reverseAPIKeys.append("gain6Index");

		if (m_dev != 0) {
			set_gain6(settings.m_gain6Index);
		}
	}

	if ((m_settings.m_LOppmTenths != settings.m_LOppmTenths) || force)
	{
		reverseAPIKeys.append("LOppmTenths");
        m_settings.m_LOppmTenths = settings.m_LOppmTenths;

		if (m_dev != 0) {
			set_lo_ppm();
		}
	}

	if ((m_settings.m_dcBlock != settings.m_dcBlock) || force)
	{
		reverseAPIKeys.append("dcBlock");
		m_deviceAPI->configureCorrections(settings.m_dcBlock, settings.m_iqCorrection);
	}

	if ((m_settings.m_iqCorrection != settings.m_iqCorrection) || force)
	{
		reverseAPIKeys.append("iqCorrection");
		m_deviceAPI->configureCorrections(settings.m_dcBlock, settings.m_iqCorrection);
	}

    if (settings.m_useReverseAPI)
    {
        bool fullUpdate = ((m_settings.m_useReverseAPI != settings.m_useReverseAPI) && settings.m_useReverseAPI) ||
                (m_settings.m_reverseAPIAddress != settings.m_reverseAPIAddress) ||
                (m_settings.m_reverseAPIPort != settings.m_reverseAPIPort) ||
                (m_settings.m_reverseAPIDeviceIndex != settings.m_reverseAPIDeviceIndex);
        webapiReverseSendSettings(reverseAPIKeys, settings, fullUpdate || force);
    }

	m_settings = settings;

    if (forwardChange)
    {
		DSPSignalNotification *notif = new DSPSignalNotification(fcd_traits<Pro>::sampleRate, m_settings.m_centerFrequency);
        m_fileSink->handleMessage(*notif); // forward to file sink
        m_deviceAPI->getDeviceEngineInputMessageQueue()->push(notif);
    }
}
Example #2
0
void FCDProPlusInput::applySettings(const FCDProPlusSettings& settings, bool force)
{
	bool signalChange = false;

	if ((m_settings.m_centerFrequency != settings.m_centerFrequency) || force)
	{
		qDebug() << "FCDProPlusInput::applySettings: fc: " << settings.m_centerFrequency;
		m_settings.m_centerFrequency = settings.m_centerFrequency;

		if (m_dev != 0)
		{
			set_center_freq((double) m_settings.m_centerFrequency);
		}

		signalChange = true;
	}

	if ((m_settings.m_lnaGain != settings.m_lnaGain) || force)
	{
		m_settings.m_lnaGain = settings.m_lnaGain;

		if (m_dev != 0)
		{
			set_lna_gain(settings.m_lnaGain);
		}
	}

	if ((m_settings.m_biasT != settings.m_biasT) || force)
	{
		m_settings.m_biasT = settings.m_biasT;

		if (m_dev != 0)
		{
			set_bias_t(settings.m_biasT);
		}
	}

	if ((m_settings.m_mixGain != settings.m_mixGain) || force)
	{
		m_settings.m_mixGain = settings.m_mixGain;

		if (m_dev != 0)
		{
			set_mixer_gain(settings.m_mixGain);
		}
	}

	if ((m_settings.m_ifGain != settings.m_ifGain) || force)
	{
		m_settings.m_ifGain = settings.m_ifGain;

		if (m_dev != 0)
		{
			set_if_gain(settings.m_ifGain);
		}
	}

	if ((m_settings.m_ifFilterIndex != settings.m_ifFilterIndex) || force)
	{
		m_settings.m_ifFilterIndex = settings.m_ifFilterIndex;

		if (m_dev != 0)
		{
			set_if_filter(settings.m_ifFilterIndex);
		}
	}

	if ((m_settings.m_rfFilterIndex != settings.m_rfFilterIndex) || force)
	{
		m_settings.m_rfFilterIndex = settings.m_rfFilterIndex;

		if (m_dev != 0)
		{
			set_rf_filter(settings.m_rfFilterIndex);
		}
	}

	if ((m_settings.m_LOppmTenths != settings.m_LOppmTenths) || force)
	{
		m_settings.m_LOppmTenths = settings.m_LOppmTenths;

		if (m_dev != 0)
		{
			set_lo_ppm();
		}
	}

	if ((m_settings.m_dcBlock != settings.m_dcBlock) || force)
	{
		m_settings.m_dcBlock = settings.m_dcBlock;
		m_deviceAPI->configureCorrections(m_settings.m_dcBlock, m_settings.m_iqImbalance);
	}

	if ((m_settings.m_iqImbalance != settings.m_iqImbalance) || force)
	{
		m_settings.m_iqImbalance = settings.m_iqImbalance;
		m_deviceAPI->configureCorrections(m_settings.m_dcBlock, m_settings.m_iqImbalance);
	}

	if (signalChange)
    {
		DSPSignalNotification *notif = new DSPSignalNotification(fcd_traits<ProPlus>::sampleRate, m_settings.m_centerFrequency);
		m_deviceAPI->getDeviceInputMessageQueue()->push(notif);
    }
}