#include <freqtrackersettings.h>

Collaboration diagram for FreqTrackerSettings:

Public Types
enum	TrackerType { TrackerNone, TrackerFLL, TrackerPLL }

Public Member Functions
	FreqTrackerSettings ()

void	resetToDefaults ()

void	setChannelMarker (Serializable *channelMarker)

QByteArray	serialize () const

bool	deserialize (const QByteArray &data)

Public Attributes
qint32	m_inputFrequencyOffset

Real	m_rfBandwidth

uint32_t	m_log2Decim

Real	m_squelch

quint32	m_rgbColor

QString	m_title

Serializable *	m_channelMarker

float	m_alphaEMA
	alpha factor for delta frequency EMA More...

bool	m_tracking

TrackerType	m_trackerType

uint32_t	m_pllPskOrder

bool	m_rrc

uint32_t	m_rrcRolloff
	in 100ths More...

int	m_squelchGate
	in 10s of ms More...

bool	m_useReverseAPI

QString	m_reverseAPIAddress

uint16_t	m_reverseAPIPort

uint16_t	m_reverseAPIDeviceIndex

uint16_t	m_reverseAPIChannelIndex

Detailed Description

Definition at line 28 of file freqtrackersettings.h.

Member Enumeration Documentation

◆ TrackerType

enum FreqTrackerSettings::TrackerType

Enumerator
TrackerNone
TrackerFLL
TrackerPLL

Definition at line 30 of file freqtrackersettings.h.

     {
         TrackerNone,
         TrackerFLL,
         TrackerPLL
     };

Constructor & Destructor Documentation

◆ FreqTrackerSettings()

FreqTrackerSettings::FreqTrackerSettings ( )

Definition at line 25 of file freqtrackersettings.cpp.

References resetToDefaults().

                                          :
     m_channelMarker(0)
 {
     resetToDefaults();
 }

Here is the call graph for this function:

Member Function Documentation

◆ deserialize()

bool FreqTrackerSettings::deserialize ( const QByteArray & data )

Definition at line 83 of file freqtrackersettings.cpp.

Referenced by FreqTrackerGUI::deserialize(), FreqTracker::deserialize(), and setChannelMarker().

 {
     SimpleDeserializer d(data);
 
     if(!d.isValid())
     {
         resetToDefaults();
         return false;
     }
 
     if(d.getVersion() == 1)
     {
         QByteArray bytetmp;
         qint32 tmp;
         uint32_t utmp;
         QString strtmp;
         float ftmp;
 
         d.readS32(1, &m_inputFrequencyOffset, 0);
         d.readS32(2, &tmp, 4);
         m_rfBandwidth = 100 * tmp;
         d.readU32(3, &utmp, 0);
         m_log2Decim = utmp > 6 ? 6 : utmp;
         d.readS32(4, &tmp, 20);
         d.readS32(5, &tmp, -40);
         m_squelch = tmp;
         d.readBlob(6, &bytetmp);
 
         if (m_channelMarker) {
             m_channelMarker->deserialize(bytetmp);
         }
 
         d.readU32(7, &m_rgbColor, QColor(200, 244, 66).rgb());
         d.readFloat(8, &ftmp, 0.1);
         m_alphaEMA = ftmp < 0.01 ? 0.01 : ftmp > 1.0 ? 1.0 : ftmp;
         d.readString(9, &m_title, "Frequency Tracker");
         d.readBool(10, &m_tracking, false);
         d.readS32(12, &tmp, 0);
         m_trackerType = tmp < 0 ? TrackerFLL : tmp > 2 ? TrackerPLL : (TrackerType) tmp;
         d.readU32(13, &utmp, 2);
         m_pllPskOrder = utmp > 32 ? 32 : utmp;
         d.readBool(14, &m_rrc, false);
         d.readU32(15, &utmp, 35);
         m_rrcRolloff = utmp > 100 ? 100 : utmp;
         d.readBool(16, &m_useReverseAPI, false);
         d.readString(17, &m_reverseAPIAddress, "127.0.0.1");
         d.readU32(18, &utmp, 0);
 
         if ((utmp > 1023) && (utmp < 65535)) {
             m_reverseAPIPort = utmp;
         } else {
             m_reverseAPIPort = 8888;
         }
 
         d.readU32(19, &utmp, 0);
         m_reverseAPIDeviceIndex = utmp > 99 ? 99 : utmp;
         d.readU32(20, &utmp, 0);
         m_reverseAPIChannelIndex = utmp > 99 ? 99 : utmp;
         d.readS32(21, &tmp, 5);
         m_squelchGate = tmp < 0 ? 0 : tmp > 99 ? 99 : tmp;
 
         return true;
     }
     else
     {
         resetToDefaults();
         return false;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ resetToDefaults()

void FreqTrackerSettings::resetToDefaults ( )

Definition at line 31 of file freqtrackersettings.cpp.

References m_alphaEMA, m_inputFrequencyOffset, m_log2Decim, m_pllPskOrder, m_reverseAPIAddress, m_reverseAPIChannelIndex, m_reverseAPIDeviceIndex, m_reverseAPIPort, m_rfBandwidth, m_rgbColor, m_rrc, m_rrcRolloff, m_squelch, m_squelchGate, m_title, m_trackerType, m_tracking, m_useReverseAPI, and TrackerFLL.

Referenced by deserialize(), FreqTracker::deserialize(), FreqTrackerSettings(), and FreqTrackerGUI::resetToDefaults().

 {
     m_inputFrequencyOffset = 0;
     m_rfBandwidth = 6000;
     m_log2Decim = 0;
     m_squelch = -40.0;
     m_rgbColor = QColor(200, 244, 66).rgb();
     m_title = "Frequency Tracker";
     m_alphaEMA = 0.1;
     m_tracking = false;
     m_trackerType = TrackerFLL;
     m_pllPskOrder = 2; // BPSK
     m_rrc = false;
     m_rrcRolloff = 35;
     m_squelchGate = 5; // 50 ms
     m_useReverseAPI = false;
     m_reverseAPIAddress = "127.0.0.1";
     m_reverseAPIPort = 8888;
     m_reverseAPIDeviceIndex = 0;
     m_reverseAPIChannelIndex = 0;
 }

Here is the caller graph for this function:

◆ serialize()

QByteArray FreqTrackerSettings::serialize ( ) const

Definition at line 53 of file freqtrackersettings.cpp.

References SimpleSerializer::final(), m_alphaEMA, m_channelMarker, m_inputFrequencyOffset, m_log2Decim, m_pllPskOrder, m_reverseAPIAddress, m_reverseAPIChannelIndex, m_reverseAPIDeviceIndex, m_reverseAPIPort, m_rfBandwidth, m_rgbColor, m_rrc, m_rrcRolloff, m_squelch, m_squelchGate, m_title, m_trackerType, m_tracking, m_useReverseAPI, Serializable::serialize(), SimpleSerializer::writeBlob(), SimpleSerializer::writeBool(), SimpleSerializer::writeFloat(), SimpleSerializer::writeS32(), SimpleSerializer::writeString(), and SimpleSerializer::writeU32().

Referenced by FreqTrackerGUI::serialize(), FreqTracker::serialize(), and setChannelMarker().

 {
     SimpleSerializer s(1);
     s.writeS32(1, m_inputFrequencyOffset);
     s.writeS32(2, m_rfBandwidth/100);
     s.writeU32(3, m_log2Decim);
     s.writeS32(5, m_squelch);
 
     if (m_channelMarker) {
         s.writeBlob(6, m_channelMarker->serialize());
     }
 
     s.writeU32(7, m_rgbColor);
     s.writeFloat(8, m_alphaEMA);
     s.writeString(9, m_title);
     s.writeBool(10, m_tracking);
     s.writeS32(12, (int) m_trackerType);
     s.writeU32(13, m_pllPskOrder);
     s.writeBool(14, m_rrc);
     s.writeU32(15, m_rrcRolloff);
     s.writeBool(16, m_useReverseAPI);
     s.writeString(17, m_reverseAPIAddress);
     s.writeU32(18, m_reverseAPIPort);
     s.writeU32(19, m_reverseAPIDeviceIndex);
     s.writeU32(20, m_reverseAPIChannelIndex);
     s.writeS32(21, m_squelchGate);
 
     return s.final();
 }