Make repeater/split screen use queue directly

bandbuttons.cpp

@@ -204,7 +204,7 @@ void bandbuttons::jumpToBandWithoutBSR(availableBands band)
                 f.Hz = (b.lowFreq+b.highFreq)/2.0;
                 f.MHzDouble = f.Hz/1000000.0;
                 f.VFO = activeVFO;
-                queue->add(priorityImmediate,queueItem(funcSelectedFreq,QVariant::fromValue<freqt>(f),false,false));
+                queue->add(priorityImmediate,queueItem(funcMainFreq,QVariant::fromValue<freqt>(f),false,false));
                 break;
             }
         }

bandbuttons.h

@@ -41,10 +41,10 @@ public:
 
 signals:
     // look at what cmdSetModeFilter does, can we depreciate it?
-    void issueCmdUniquePriority(cmds cmd, char c); // to go to a mode
-    void issueDelayedCommand(cmds cmd); // for data mode and filter
-    void issueCmdF(cmds cmd, freqt f); // go to frequency
-    void issueCmd(cmds, char); // to get BSR of a specific band
+    //void issueCmdUniquePriority(cmds cmd, char c); // to go to a mode
+    //void issueDelayedCommand(cmds cmd); // for data mode and filter
+    //void issueCmdF(cmds cmd, freqt f); // go to frequency
+    //void issueCmd(cmds, char); // to get BSR of a specific band
 
     // void getBandStackReg(char band, char regCode); // no, use the queue.
     // void gotoFreqMode(); // TODO, arguments will contain BSR data

cachingqueue.cpp

@@ -81,12 +81,12 @@ void cachingQueue::run()
                 }
                 it--;
                 auto item = it.value();
-                emit haveCommand(item.command,item.param,item.vfo);
+                emit haveCommand(item.command,item.param,item.receiver);
                 it=queue.erase(it);
                 if (item.recurring && prio != priorityImmediate) {
                     queue.insert(prio,item);
                 }
-                updateCache(false,item.command,item.param,item.vfo);
+                updateCache(false,item.command,item.param,item.receiver);
             }
 
             QCoreApplication::processEvents();
@@ -109,18 +109,55 @@ void cachingQueue::interval(quint64 val)
     qInfo() << "Changing queue interval to" << val << "ms";
 }
 
-void cachingQueue::add(queuePriority prio ,funcs func, bool recurring, uchar vfo)
+funcs cachingQueue::checkCommandAvailable(funcs cmd,bool set)
 {
-    queueItem q(func,recurring,vfo);
+
+    // If we don't have rigCaps yet, simply return the command.
+    if (rigCaps != Q_NULLPTR && cmd != funcNone && !rigCaps->commands.contains(cmd)) {
+        // We don't have the requested command, so lets see if we can change it to something we do have.
+        // WFVIEW functions should use funcMain/Sub commands by default,
+        if (cmd == funcMainFreq && rigCaps->commands.contains(funcSelectedFreq))
+            cmd = funcSelectedFreq;
+        else if (cmd == funcSubFreq && rigCaps->commands.contains(funcUnselectedFreq))
+            cmd = funcSelectedFreq;
+        else if (cmd == funcMainMode && rigCaps->commands.contains(funcSelectedMode))
+            cmd = funcSelectedMode;
+        else if (cmd == funcSubMode && rigCaps->commands.contains(funcUnselectedMode))
+            cmd = funcUnselectedFreq;
+        // These are fallback commands for older radios that don't have command 25/26
+        else if(cmd == funcMainMode)
+        {
+            if (set)
+                cmd = funcModeSet;
+            else
+                cmd = funcModeGet;
+        }
+        else if(cmd == funcMainFreq)
+        {
+            if (set)
+                cmd = funcFreqSet;
+            else
+                cmd = funcFreqGet;
+        }
+        else
+            cmd = funcNone;
+    }
+    return cmd;
+}
+
+void cachingQueue::add(queuePriority prio ,funcs func, bool recurring, uchar receiver)
+{
+    queueItem q(func,recurring,receiver);
     add(prio,q);
 }
 
 void cachingQueue::add(queuePriority prio ,queueItem item)
 {
+    item.command=checkCommandAvailable(item.command,item.param.isValid());
     if (item.command != funcNone)
     {
         QMutexLocker locker(&mutex);
-        if (!item.recurring || isRecurring(item.command,item.vfo) != prio)
+        if (!item.recurring || isRecurring(item.command,item.receiver) != prio)
         {
             if (item.recurring && prio == queuePriority::priorityImmediate) {
                 qWarning() << "Warning, cannot add recurring command with immediate priority!" << funcString[item.command];
@@ -130,7 +167,7 @@ void cachingQueue::add(queuePriority prio ,queueItem item)
                     queueItem it=item;
                     it.recurring=false;
                     queue.insert(queue.cend(),priorityImmediate, it);
-                    qDebug() << "adding" << funcString[item.command] << "recurring" << item.recurring << "priority" << prio << "vfo" << item.vfo;
+                    qDebug() << "adding" << funcString[item.command] << "recurring" << item.recurring << "priority" << prio << "receiver" << item.receiver;
                 }
                 queue.insert(prio, item);
             }
@@ -138,9 +175,10 @@ void cachingQueue::add(queuePriority prio ,queueItem item)
     }
 }
 
-void cachingQueue::addUnique(queuePriority prio ,funcs func, bool recurring, uchar vfo)
+
+void cachingQueue::addUnique(queuePriority prio ,funcs func, bool recurring, uchar receiver)
 {
-    queueItem q(func,recurring, vfo);
+    queueItem q(func,recurring, receiver);
     addUnique(prio,q);
 }
 
@@ -148,6 +186,7 @@ void cachingQueue::addUnique(queuePriority prio ,funcs func, bool recurring, uch
 
 void cachingQueue::addUnique(queuePriority prio ,queueItem item)
 {
+    item.command=checkCommandAvailable(item.command,item.param.isValid());
     if (item.command != funcNone)
     {
         QMutexLocker locker(&mutex);
@@ -157,9 +196,9 @@ void cachingQueue::addUnique(queuePriority prio ,queueItem item)
             auto it(queue.begin());
             // This is quite slow but a new unique command is only added in response to user interaction (mode change etc.)
             while (it != queue.end()) {
-                if (it.value().command == item.command && it.value().recurring == item.recurring && it.value().vfo == item.vfo && it.value().param.isValid() == item.param.isValid())
+                if (it.value().command == item.command && it.value().recurring == item.recurring && it.value().receiver == item.receiver && it.value().param.isValid() == item.param.isValid())
                 {
-                    qDebug() << "deleting" << it.value().id << funcString[it.value().command] << "VFO" << it.value().vfo << "recurring" << it.value().recurring ;
+                    qDebug() << "deleting" << it.value().id << funcString[it.value().command] << "VFO" << it.value().receiver << "recurring" << it.value().recurring ;
                     it = queue.erase(it);
                 }
                 else
@@ -172,26 +211,26 @@ void cachingQueue::addUnique(queuePriority prio ,queueItem item)
                 queueItem it = item;
                 it.recurring=false;
                 queue.insert(queue.cend(),priorityImmediate, it);
-                qDebug() << "adding unique" << funcString[item.command] << "recurring" << item.recurring << "priority" << prio << "vfo" << item.vfo;
+                qDebug() << "adding unique" << funcString[item.command] << "recurring" << item.recurring << "priority" << prio << "receiver" << item.receiver;
             }
             queue.insert(prio, item);
         }
     }
 }
 
-void cachingQueue::del(funcs func, uchar vfo)
+void cachingQueue::del(funcs func, uchar receiver)
 {
     // This will immediately delete any matching commands.
     if (func != funcNone)
     {
         QMutexLocker locker(&mutex);
-        auto it = std::find_if(queue.begin(), queue.end(), [func,vfo](const queueItem& c) {  return (c.command == func && c.vfo == vfo && c.recurring); });
+        auto it = std::find_if(queue.begin(), queue.end(), [func,receiver](const queueItem& c) {  return (c.command == func && c.receiver == receiver && c.recurring); });
         //auto it(queue.begin());
         if (it == queue.end())
-            qInfo() << "recurring command" << funcString[func] << "vfo" << vfo << "not found in queue";
+            qInfo() << "recurring command" << funcString[func] << "receiver" << receiver << "not found in queue";
         while (it != queue.end()) {
-            if (it.value().command == func && it.value().vfo == vfo) {
-                qDebug() << "deleting" << funcString[it.value().command] << "VFO" << it.value().vfo << "recurring" << it.value().recurring;
+            if (it.value().command == func && it.value().receiver == receiver) {
+                qDebug() << "deleting" << funcString[it.value().command] << "VFO" << it.value().receiver << "recurring" << it.value().recurring;
                 it = queue.erase(it);
             }
             else
@@ -202,10 +241,10 @@ void cachingQueue::del(funcs func, uchar vfo)
     }
 }
 
-queuePriority cachingQueue::isRecurring(funcs func, uchar vfo)
+queuePriority cachingQueue::isRecurring(funcs func, uchar receiver)
 {
     // Does NOT lock the mutex
-    auto rec = std::find_if(queue.begin(), queue.end(), [func,vfo](const queueItem& c) {  return (c.command == func && c.vfo == vfo && c.recurring); });
+    auto rec = std::find_if(queue.begin(), queue.end(), [func,receiver](const queueItem& c) {  return (c.command == func && c.receiver == receiver && c.recurring); });
     if (rec != queue.end())
     {
         return rec.key();
@@ -224,12 +263,12 @@ void cachingQueue::message(QString msg)
     waiting.wakeOne();
 }
 
-void cachingQueue::receiveValue(funcs func, QVariant value, uchar vfo)
+void cachingQueue::receiveValue(funcs func, QVariant value, uchar receiver)
 {
     QMutexLocker locker(&mutex);
-    cacheItem c = cacheItem(func,value,vfo);
+    cacheItem c = cacheItem(func,value,receiver);
     items.enqueue(c);
-    updateCache(true,func,value,vfo);
+    updateCache(true,func,value,receiver);
     waiting.wakeOne();
 }
 
@@ -239,7 +278,7 @@ void cachingQueue::updateCache(bool reply, queueItem item)
     // Mutex MUST be locked by the calling function.
     auto cv = cache.find(item.command);
     while (cv != cache.end() && cv->command == item.command) {
-        if (cv->vfo == item.vfo) {
+        if (cv->receiver == item.receiver) {
             if (reply) {
                 cv->reply = QDateTime::currentDateTime();
             } else {
@@ -261,7 +300,7 @@ void cachingQueue::updateCache(bool reply, queueItem item)
 
     cacheItem c;
     c.command = item.command;
-    c.vfo = item.vfo;
+    c.receiver = item.receiver;
     if (reply) {
         c.reply = QDateTime::currentDateTime();
     } else {
@@ -275,14 +314,14 @@ void cachingQueue::updateCache(bool reply, queueItem item)
 }
 
 
-void cachingQueue::updateCache(bool reply, funcs func, QVariant value, uchar vfo)
+void cachingQueue::updateCache(bool reply, funcs func, QVariant value, uchar receiver)
 {
-    queueItem q(func,value,false,vfo);
+    queueItem q(func,value,false,receiver);
     updateCache(reply,q);
 }
 
 
-cacheItem cachingQueue::getCache(funcs func, uchar vfo)
+cacheItem cachingQueue::getCache(funcs func, uchar receiver)
 {
     cacheItem ret;
     if (func != funcNone) {
@@ -290,7 +329,7 @@ cacheItem cachingQueue::getCache(funcs func, uchar vfo)
         auto it = cache.find(func);
         while (it != cache.end() && it->command == func)
         {
-            if (it->vfo == vfo)
+            if (it->receiver == receiver)
                 ret = cacheItem(*it);
             ++it;
         }
@@ -299,7 +338,7 @@ cacheItem cachingQueue::getCache(funcs func, uchar vfo)
     // Using priorityhighest WILL slow down the S-Meter when a command intensive client is connected to rigctl
     if (func != funcNone && (!ret.value.isValid() || ret.reply.addSecs(QRandomGenerator::global()->bounded(5,20)) <= QDateTime::currentDateTime())) {
         //qInfo() << "No (or expired) cache found for" << funcString[func] << "requesting";
-        add(priorityHighest,func,false,vfo);
+        add(priorityHighest,func,false,receiver);
     }
     return ret;
 }

cachingqueue.h

@@ -27,28 +27,28 @@ inline QMap<QString,int> priorityMap = {{"None",0},{"Immediate",1},{"Highest",2}
 // Command with no param is a get by default
 struct queueItem {
     queueItem () {}
-    queueItem (funcs command, QVariant param, bool recurring, uchar vfo) : command(command), param(param), vfo(vfo), recurring(recurring){};
-    queueItem (funcs command, QVariant param, bool recurring) : command(command), param(param), vfo(false), recurring(recurring){};
-    queueItem (funcs command, QVariant param) : command(command), param(param),vfo(0), recurring(false){};
-    queueItem (funcs command, bool recurring, uchar vfo) : command(command), param(QVariant()), vfo(vfo), recurring(recurring) {};
-    queueItem (funcs command, bool recurring) : command(command), param(QVariant()), vfo(0), recurring(recurring) {};
-    queueItem (funcs command) : command(command), param(QVariant()), vfo(0), recurring(false){};
+    queueItem (funcs command, QVariant param, bool recurring, uchar receiver) : command(command), param(param), receiver(receiver), recurring(recurring){};
+    queueItem (funcs command, QVariant param, bool recurring) : command(command), param(param), receiver(false), recurring(recurring){};
+    queueItem (funcs command, QVariant param) : command(command), param(param),receiver(0), recurring(false){};
+    queueItem (funcs command, bool recurring, uchar receiver) : command(command), param(QVariant()), receiver(receiver), recurring(recurring) {};
+    queueItem (funcs command, bool recurring) : command(command), param(QVariant()), receiver(0), recurring(recurring) {};
+    queueItem (funcs command) : command(command), param(QVariant()), receiver(0), recurring(false){};
     funcs command;
     QVariant param;
-    uchar vfo;
+    uchar receiver;
     bool recurring;
     qint64 id = QDateTime::currentMSecsSinceEpoch();
 };
 
 struct cacheItem {
     cacheItem () {};
-    cacheItem (funcs command, QVariant value, uchar vfo=0) : command(command), req(QDateTime()), reply(QDateTime()), value(value), vfo(vfo){};
+    cacheItem (funcs command, QVariant value, uchar receiver=0) : command(command), req(QDateTime()), reply(QDateTime()), value(value), receiver(receiver){};
 
     funcs command;
     QDateTime req;
     QDateTime reply;
     QVariant value;
-    uchar vfo;
+    uchar receiver;
 };
 
 class cachingQueue : public QThread
@@ -56,14 +56,14 @@ class cachingQueue : public QThread
     Q_OBJECT
 
 signals:
-    void haveCommand(funcs func, QVariant param, uchar vfo);
+    void haveCommand(funcs func, QVariant param, uchar receiver);
     void sendValue(cacheItem item);
     void cacheUpdated(cacheItem item);
     void rigCapsUpdated(rigCapabilities* caps);
 
 public slots:
     // Can be called directly or via emit.
-    void receiveValue(funcs func, QVariant value, uchar vfo);
+    void receiveValue(funcs func, QVariant value, uchar receiver);
 
 private:
 
@@ -77,8 +77,8 @@ private:
     QQueue<cacheItem> items;
 
     // Command to set cache value
-    void setCache(funcs func, QVariant val, uchar vfo=0);
-    queuePriority isRecurring(funcs func, uchar vfo=0);
+    void setCache(funcs func, QVariant val, uchar receiver=0);
+    queuePriority isRecurring(funcs func, uchar receiver=0);
     bool compare(QVariant a, QVariant b);
 
 
@@ -91,6 +91,7 @@ private:
     
     // Functions
     void run();
+    funcs checkCommandAvailable(funcs cmd, bool set=false);
 
 protected:
     cachingQueue(QObject* parent = Q_NULLPTR) : QThread(parent) {};
@@ -102,17 +103,17 @@ public:
 
     static cachingQueue *getInstance(QObject* parent = Q_NULLPTR);
     void message(QString msg);
-    void add(queuePriority prio ,funcs func, bool recurring=false, uchar vfo=0);
+    void add(queuePriority prio ,funcs func, bool recurring=false, uchar receiver=0);
     void add(queuePriority prio,queueItem item);
-    void addUnique(queuePriority prio ,funcs func, bool recurring=false, uchar vfo=0);
+    void addUnique(queuePriority prio ,funcs func, bool recurring=false, uchar receiver=0);
     void addUnique(queuePriority prio,queueItem item);
-    void del(funcs func, uchar vfo=0);
+    void del(funcs func, uchar receiver=0);
     void clear();
     void interval(quint64 val);
     void updateCache(bool reply, queueItem item);
-    void updateCache(bool reply, funcs func, QVariant value=QVariant(), uchar vfo=0);
+    void updateCache(bool reply, funcs func, QVariant value=QVariant(), uchar receiver=0);
 
-    cacheItem getCache(funcs func, uchar vfo=0);
+    cacheItem getCache(funcs func, uchar receiver=0);
 
     QMultiMap<funcs,cacheItem> getCacheItems();
     QMultiMap <queuePriority,queueItem> getQueueItems();

cluster.cpp

@@ -263,10 +263,10 @@ void dxClusterClient::tcpDisconnected() {
     // Need to start a timer and attempt reconnect.
 }
 
-void dxClusterClient::freqRange(uchar vfo, double low, double high)
+void dxClusterClient::freqRange(uchar receiver, double low, double high)
 {
-    freqRanges[vfo] = {low,high};
-    if (vfo) {
+    freqRanges[receiver] = {low,high};
+    if (receiver) {
         lowSubFreq = low;
         highSubFreq = high;
     } else {
@@ -310,7 +310,7 @@ void dxClusterClient::updateSpots()
         }
         if (!spots.empty()) {
             emit sendSpots(range.key(),spots);
-            //qInfo(logCluster()) << "Sending" << spots.size() << "DX spots to vfo" << range.key();
+            //qInfo(logCluster()) << "Sending" << spots.size() << "DX spots to receiver" << range.key();
         }
         ++range;
     }

cluster.h

@@ -63,7 +63,7 @@ signals:
     void deleteSpot(QString dxcall);
     void deleteOldSpots(int minutes);
     void sendOutput(QString text);
-    void sendSpots(uchar vfo, QList<spotData> spots);
+    void sendSpots(uchar receiver, QList<spotData> spots);
     void sendSubSpots(QList<spotData> spots);
 
 public slots:
@@ -79,7 +79,7 @@ public slots:
     void setTcpPassword(QString s) { tcpPassword = s; }
     void setTcpTimeout(int p) { tcpTimeout = p; }
     void tcpCleanup();
-    void freqRange(uchar vfo, double low, double high);
+    void freqRange(uchar receiver, double low, double high);
     void enableSkimmerSpots(bool enable);
 
 private:

controllersetup.cpp

@@ -127,7 +127,7 @@ void controllerSetup::init(usbDevMap* dev, QVector<BUTTON>* but, QVector<KNOB>*
 
     for (COMMAND& c : *commands) {
         if (c.cmdType == commandButton || c.cmdType == commandAny) {
-            if (c.command == cmdSeparator) {
+            if (c.command == funcSeparator) {
                 onEvent->insertSeparator(onEvent->count());
                 offEvent->insertSeparator(offEvent->count());
 
@@ -137,7 +137,7 @@ void controllerSetup::init(usbDevMap* dev, QVector<BUTTON>* but, QVector<KNOB>*
             }
         }
         if (c.cmdType == commandKnob || c.cmdType == commandAny) {
-            if (c.command == cmdSeparator) {
+            if (c.command == funcSeparator) {
                 knobEvent->insertSeparator(knobEvent->count());
             } else {
                 knobEvent->addItem(c.text, c.index);

debugwindow.cpp

@@ -58,7 +58,7 @@ void debugWindow::getCache()
         ui->cacheView->item(c,0)->setText(QString::number(i.value().command).rightJustified(3,'0'));
         ui->cacheView->item(c,1)->setText(funcString[i.value().command]);
         ui->cacheView->item(c,2)->setText(getValue(i.value().value));
-        ui->cacheView->item(c,3)->setText(QString::number(i.value().vfo));
+        ui->cacheView->item(c,3)->setText(QString::number(i.value().receiver));
         ui->cacheView->item(c,4)->setText((i.value().req.isValid()?i.value().req.toString("hh:mm:ss.zzz"):"<none>"));
         ui->cacheView->item(c,5)->setText((i.value().reply.isValid()?i.value().reply.toString("hh:mm:ss.zzz"):"<none>"));
         c++;
@@ -141,7 +141,7 @@ QString debugWindow::getValue(QVariant val)
         else if(!strcmp(val.typeName(),"scopeData"))
         {
             scopeData s = val.value<scopeData>();
-            value = QString("(V:%0) %1").arg(s.vfo).arg((s.valid?"Valid":"Invalid"));
+            value = QString("(V:%0) %1").arg(s.receiver).arg((s.valid?"Valid":"Invalid"));
         }
         else if (!strcmp(val.typeName(),"antennaInfo"))
         {

frequencyinputwidget.cpp

@@ -205,14 +205,14 @@ void frequencyinputwidget::on_goFreqBtn_clicked()
         // TODO: auto sideband preference
         if((m.mk != currentMode) && !usingDataMode && automaticSidebandSwitching)
         {
-            queue->add(priorityImmediate,queueItem(funcSelectedMode,QVariant::fromValue<modeInfo>(m),false,false));
+            queue->add(priorityImmediate,queueItem(funcMainMode,QVariant::fromValue<modeInfo>(m),false,false));
             currentMode = m.mk;
         }
 
         f.MHzDouble = (float)f.Hz / 1E6;
         //emit updateUIFrequency(f);
         currentFrequency = f;
-        queue->add(priorityImmediate,queueItem(funcSelectedFreq,QVariant::fromValue<freqt>(f),false,false));
+        queue->add(priorityImmediate,queueItem(funcMainFreq,QVariant::fromValue<freqt>(f),false,false));
     } else {
         qWarning(logGui()) << "Could not understand frequency" << ui->freqMhzLineEdit->text();
         ui->freqMhzLineEdit->clear();

frequencyinputwidget.h

@@ -22,8 +22,8 @@ public:
     ~frequencyinputwidget();
 
 signals:
-    void issueCmdF(cmds cmd, freqt f);
-    void issueCmdM(cmds cmd, modeInfo m);
+    //void issueCmdF(cmds cmd, freqt f);
+    //void issueCmdM(cmds cmd, modeInfo m);
     void updateUIMode(rigMode_t mode);
     void updateUIFrequency(freqt f);
     void gotoMemoryPreset(int presetNumber);

memories.cpp

@@ -465,16 +465,16 @@ void memories::on_group_currentIndexChanged(int index)
 
     queue->add(priorityImmediate,queueItem(funcSatelliteMode,QVariant::fromValue<bool>(ui->group->currentData().toInt() == MEMORY_SATGROUP)));
     if (ui->group->currentData().toInt() == MEMORY_SATGROUP) {
-        queue->del(funcSelectedFreq,false);
-        queue->del(funcSelectedMode,false);
-        queue->del(funcUnselectedFreq,true);
-        queue->del(funcUnselectedMode,true);
+        queue->del(funcMainFreq,false);
+        queue->del(funcMainMode,false);
+        queue->del(funcSubFreq,true);
+        queue->del(funcSubMode,true);
         parser = rigCaps->satParser;
     } else {
-        queue->addUnique(priorityMedium,funcSelectedFreq,true,false);
-        queue->addUnique(priorityMedium,funcSelectedMode,true,false);
-        queue->addUnique(priorityMedium,funcUnselectedFreq,true,true);
-        queue->addUnique(priorityMedium,funcUnselectedMode,true,true);
+        queue->addUnique(priorityMedium,funcMainFreq,true,false);
+        queue->addUnique(priorityMedium,funcMainMode,true,false);
+        queue->addUnique(priorityMedium,funcSubFreq,true,true);
+        queue->addUnique(priorityMedium,funcSubMode,true,true);
         parser = rigCaps->memParser;
     }
 
@@ -925,19 +925,19 @@ void memories::on_group_currentIndexChanged(int index)
 
 void memories::on_vfoMode_clicked()
 {
-    queue->addUnique(priorityMedium,funcSelectedFreq,true,false);
-    queue->addUnique(priorityMedium,funcSelectedMode,true,false);
-    queue->addUnique(priorityMedium,funcUnselectedFreq,true,true);
-    queue->addUnique(priorityMedium,funcUnselectedMode,true,true);
+    queue->addUnique(priorityMedium,funcMainFreq,true,false);
+    queue->addUnique(priorityMedium,funcMainMode,true,false);
+    queue->addUnique(priorityMedium,funcSubFreq,true,true);
+    queue->addUnique(priorityMedium,funcSubMode,true,true);
 }
 
 void memories::on_memoryMode_clicked()
 {
     queue->add(priorityImmediate,funcMemoryMode);
-    queue->del(funcSelectedFreq,false);
-    queue->del(funcSelectedMode,false);
-    queue->del(funcUnselectedFreq,true);
-    queue->del(funcUnselectedMode,true);
+    queue->del(funcMainFreq,false);
+    queue->del(funcMainMode,false);
+    queue->del(funcSubFreq,true);
+    queue->del(funcSubMode,true);
 }
 
 

repeatersetup.cpp

@@ -7,6 +7,12 @@ repeaterSetup::repeaterSetup(QWidget *parent) :
 {
     ui->setupUi(this);
 
+    this->setObjectName("RepeaterSetup");
+    queue = cachingQueue::getInstance(this);
+    connect(queue, SIGNAL(rigCapsUpdated(rigCapabilities*)), this, SLOT(receiveRigCaps(rigCapabilities*)));
+    rigCaps = queue->getRigCaps();
+    receiveRigCaps(rigCaps);
+
     ui->autoTrackLiveBtn->setEnabled(false); // until we set split enabled.
     ui->warningFMLabel->setVisible(false);
     // populate the CTCSS combo box:
@@ -19,103 +25,9 @@ repeaterSetup::repeaterSetup(QWidget *parent) :
 repeaterSetup::~repeaterSetup()
 {
     // Trying this for more consistent destruction
-    rig.inputs.clear();
-    rig.preamps.clear();
-    rig.attenuators.clear();
-    rig.antennas.clear();
-
     delete ui;
 }
 
-void repeaterSetup::setRig(rigCapabilities inRig)
-{
-    this->rig = inRig;
-    haveRig = true;
-    if(rig.commands.contains(funcRepeaterTone)) {
-        ui->rptToneCombo->setDisabled(false);
-        ui->toneTone->setDisabled(false);
-    } else {
-        ui->rptToneCombo->setDisabled(true);
-        ui->toneTone->setDisabled(true);
-    }
-
-    if(rig.commands.contains(funcRepeaterTSQL)) {
-        ui->toneTSQL->setDisabled(false);
-    } else {
-        ui->toneTSQL->setDisabled(true);
-    }
-
-    if(rig.commands.contains(funcToneSquelchType))
-    {
-        ui->rptToneCombo->setDisabled(false);
-        ui->toneTone->setDisabled(false);
-        ui->toneTSQL->setDisabled(false);
-    }
-
-    if(rig.commands.contains(funcRepeaterDTCS))
-    {
-        ui->rptDTCSCombo->setDisabled(false);
-        ui->toneDTCS->setDisabled(false);
-        ui->rptDTCSInvertRx->setDisabled(false);
-        ui->rptDTCSInvertTx->setDisabled(false);
-    } else {
-        ui->rptDTCSCombo->setDisabled(true);
-        ui->toneDTCS->setDisabled(true);
-        ui->rptDTCSInvertRx->setDisabled(true);
-        ui->rptDTCSInvertTx->setDisabled(true);
-    }
-    if(rig.commands.contains(funcVFOEqualAB))
-    {
-        ui->selABtn->setDisabled(false);
-        ui->selBBtn->setDisabled(false);
-        ui->aEqBBtn->setDisabled(false);
-        ui->swapABBtn->setDisabled(false);
-    } else {
-        ui->selABtn->setDisabled(true);
-        ui->selBBtn->setDisabled(true);
-        ui->aEqBBtn->setDisabled(true);
-        ui->swapABBtn->setDisabled(true);
-    }
-    if(rig.commands.contains(funcVFOEqualMS))
-    {
-        ui->selMainBtn->setDisabled(false);
-        ui->selSubBtn->setDisabled(false);
-        ui->mEqSBtn->setDisabled(false);
-        ui->swapMSBtn->setDisabled(false);
-    } else {
-        ui->selMainBtn->setDisabled(true);
-        ui->selSubBtn->setDisabled(true);
-        ui->mEqSBtn->setDisabled(true);
-        ui->swapMSBtn->setDisabled(true);
-    }
-    if(rig.commands.contains(funcVFOEqualAB) && rig.commands.contains(funcVFOEqualMS))
-    {
-        // Rigs that have both AB and MS
-        // do not have a swap AB command.
-        ui->swapABBtn->setDisabled(true);
-    }
-    bool mainSub = rig.commands.contains(funcVFOMainSelect);
-    if(mainSub)
-    {
-        ui->setRptrSubVFOBtn->setEnabled(true);
-        ui->setToneSubVFOBtn->setEnabled(true);
-        ui->setSplitRptrToneChk->setEnabled(true);
-    } else {
-        ui->setRptrSubVFOBtn->setDisabled(true);
-        ui->setToneSubVFOBtn->setDisabled(true);
-        ui->setSplitRptrToneChk->setDisabled(true);
-    }
-    bool rpt = rig.commands.contains(funcToneSquelchType);
-    ui->rptAutoBtn->setEnabled(rpt);
-    ui->rptDupMinusBtn->setEnabled(rpt);
-    ui->rptDupPlusBtn->setEnabled(rpt);
-    ui->rptSimplexBtn->setEnabled(rpt);
-    ui->rptrOffsetEdit->setEnabled(rpt);
-    ui->rptrOffsetSetBtn->setEnabled(rpt);
-    ui->setToneSubVFOBtn->setEnabled(mainSub);
-    ui->setRptrSubVFOBtn->setEnabled(mainSub);
-    ui->quickSplitChk->setVisible(rig.commands.contains(funcQuickSplit));
-}
 
 void repeaterSetup::populateTones()
 {
@@ -461,17 +373,17 @@ void repeaterSetup::handleTransmitStatus(bool amTransmitting)
 
 void repeaterSetup::showEvent(QShowEvent *event)
 {
-    emit getDuplexMode();
-    emit getSplitModeEnabled();
-    if(rig.commands.contains(funcToneSquelchType))
-        emit getRptDuplexOffset();
+
+    queue->add(priorityImmediate,funcSplitStatus,false,false);
+    if(rigCaps->commands.contains(funcToneSquelchType))
+        queue->add(priorityImmediate,funcReadFreqOffset,false,false);
     QMainWindow::showEvent(event);
     (void)event;
 }
 
 void repeaterSetup::on_splitEnableChk_clicked()
 {
-    emit setDuplexMode(dmSplitOn);
+    queue->add(priorityImmediate,queueItem(funcSplitStatus,QVariant::fromValue<duplexMode_t>(dmSplitOn),false));
     ui->autoTrackLiveBtn->setEnabled(true);
 
     if(ui->autoTrackLiveBtn->isChecked() && !ui->splitOffsetEdit->text().isEmpty())
@@ -487,40 +399,40 @@ void repeaterSetup::on_splitEnableChk_clicked()
 
 void repeaterSetup::on_splitOffBtn_clicked()
 {
-    emit setDuplexMode(dmSplitOff);
+    queue->add(priorityImmediate,queueItem(funcSplitStatus,QVariant::fromValue<duplexMode_t>(dmSplitOff),false));
     ui->autoTrackLiveBtn->setDisabled(true);
 }
 
 void repeaterSetup::on_rptSimplexBtn_clicked()
 {
     // Simplex
-    emit setDuplexMode(dmSplitOff);
-    if(rig.commands.contains(funcToneSquelchType))
+    queue->add(priorityImmediate,queueItem(funcSplitStatus,QVariant::fromValue<duplexMode_t>(dmSplitOn),false));
+    if(rigCaps->commands.contains(funcToneSquelchType))
     {
-        emit setDuplexMode(dmDupAutoOff);
-        emit setDuplexMode(dmSimplex);
+        queue->add(priorityImmediate,queueItem(funcSplitStatus,QVariant::fromValue<duplexMode_t>(dmDupAutoOff),false));
+        queue->add(priorityImmediate,queueItem(funcSplitStatus,QVariant::fromValue<duplexMode_t>(dmSimplex),false));
     }
 }
 
 void repeaterSetup::on_rptDupPlusBtn_clicked()
 {
     // DUP+
-    emit setDuplexMode(dmDupAutoOff);
-    emit setDuplexMode(dmDupPlus);
+    queue->add(priorityImmediate,queueItem(funcSplitStatus,QVariant::fromValue<duplexMode_t>(dmDupAutoOff),false));
+    queue->add(priorityImmediate,queueItem(funcSplitStatus,QVariant::fromValue<duplexMode_t>(dmDupPlus),false));
 }
 
 void repeaterSetup::on_rptDupMinusBtn_clicked()
 {
     // DUP-
-    emit setDuplexMode(dmDupAutoOff);
-    emit setDuplexMode(dmDupMinus);
+    queue->add(priorityImmediate,queueItem(funcSplitStatus,QVariant::fromValue<duplexMode_t>(dmDupAutoOff),false));
+    queue->add(priorityImmediate,queueItem(funcSplitStatus,QVariant::fromValue<duplexMode_t>(dmDupMinus),false));
 }
 
 void repeaterSetup::on_rptAutoBtn_clicked()
 {
     // Auto Rptr (enable this feature)
     // TODO: Hide an AutoOff button somewhere for non-US users
-    emit setDuplexMode(dmDupAutoOn);
+    queue->add(priorityImmediate,queueItem(funcSplitStatus,QVariant::fromValue<duplexMode_t>(dmDupAutoOn),false));
 }
 
 void repeaterSetup::on_rptToneCombo_activated(int tindex)
@@ -532,19 +444,19 @@ void repeaterSetup::on_rptToneCombo_activated(int tindex)
     bool updateSub = ui->setSplitRptrToneChk->isEnabled() && ui->setSplitRptrToneChk->isChecked();
     if(ui->toneTone->isChecked())
     {
-        emit setTone(rt);
+        queue->add(priorityImmediate,queueItem(funcToneFreq,QVariant::fromValue<toneInfo>(rt),false, rt.useSecondaryVFO));
         if(updateSub)
         {
             rt.useSecondaryVFO = true;
-            emit setTone(rt);
+            queue->add(priorityImmediate,queueItem(funcToneFreq,QVariant::fromValue<toneInfo>(rt),false, rt.useSecondaryVFO));
         }
 
     } else if (ui->toneTSQL->isChecked()) {
-        emit setTSQL(rt);
+        queue->add(priorityImmediate,queueItem(funcToneFreq,QVariant::fromValue<toneInfo>(rt),false, rt.useSecondaryVFO));
         if(updateSub)
         {
             rt.useSecondaryVFO = true;
-            emit setTone(rt);
+            queue->add(priorityImmediate,queueItem(funcToneFreq,QVariant::fromValue<toneInfo>(rt),false, rt.useSecondaryVFO));
         }
     }
 }
@@ -555,7 +467,24 @@ void repeaterSetup::on_rptDTCSCombo_activated(int index)
     tone.tinv = ui->rptDTCSInvertTx->isChecked();
     tone.rinv = ui->rptDTCSInvertRx->isChecked();
     tone.tone = (quint16)ui->rptDTCSCombo->itemData(index).toUInt();
-    emit setDTCS(tone);
+    queue->add(priorityImmediate,queueItem(funcRepeaterDTCS,QVariant::fromValue<toneInfo>(tone),false));
+}
+
+void repeaterSetup::setRptAccessMode(rptrAccessData rd)
+{
+    if (rigCaps->commands.contains(funcToneSquelchType)) {
+        queue->add(priorityImmediate,queueItem(funcToneSquelchType,QVariant::fromValue<rptrAccessData>(rd),false));
+    } else {
+        if(rd.accessMode == ratrTN) {
+            // recuring=false, vfo if rd.useSEcondaryVFO
+            queue->add(priorityImmediate,queueItem(funcRepeaterTone, QVariant::fromValue<bool>(true), false, rd.useSecondaryVFO));
+        } else if (rd.accessMode == ratrTT) {
+            queue->add(priorityImmediate,queueItem(funcRepeaterTSQL, QVariant::fromValue<bool>(true), false, rd.useSecondaryVFO));
+        } else if (rd.accessMode == ratrNN) {
+            queue->add(priorityImmediate,queueItem(funcRepeaterTone, QVariant::fromValue<bool>(false), false, rd.useSecondaryVFO));
+            queue->add(priorityImmediate,queueItem(funcRepeaterTSQL, QVariant::fromValue<bool>(false), false, rd.useSecondaryVFO));
+        }
+    }
 }
 
 void repeaterSetup::on_toneNone_clicked()
@@ -564,13 +493,13 @@ void repeaterSetup::on_toneNone_clicked()
     rptrAccessData rd;
     rm = ratrNN;
     rd.accessMode = rm;
-    emit setRptAccessMode(rd);
+    setRptAccessMode(rd);
     bool updateSub = ui->setSplitRptrToneChk->isEnabled() && ui->setSplitRptrToneChk->isChecked();
 
     if(updateSub)
     {
         rd.useSecondaryVFO = true;
-        emit setRptAccessMode(rd);
+        setRptAccessMode(rd);
     }
 }
 
@@ -582,8 +511,8 @@ void repeaterSetup::on_toneTone_clicked()
     rd.accessMode = rm;
     toneInfo rt;
     rt.tone = (quint16)ui->rptToneCombo->currentData().toUInt();
-    emit setRptAccessMode(rd);
-    emit setTone(rt);
+    setRptAccessMode(rd);
+    queue->add(priorityImmediate,queueItem(funcToneFreq,QVariant::fromValue<toneInfo>(rt),false, rt.useSecondaryVFO));
 
     bool updateSub = ui->setSplitRptrToneChk->isEnabled() && ui->setSplitRptrToneChk->isChecked();
 
@@ -591,8 +520,8 @@ void repeaterSetup::on_toneTone_clicked()
     {
         rd.useSecondaryVFO = true;
         rt.useSecondaryVFO = true;
-        emit setRptAccessMode(rd);
-        emit setTone(rt);
+        setRptAccessMode(rd);
+        queue->add(priorityImmediate,queueItem(funcToneFreq,QVariant::fromValue<toneInfo>(rt),false, rt.useSecondaryVFO));
     }
 }
 
@@ -604,16 +533,16 @@ void repeaterSetup::on_toneTSQL_clicked()
     toneInfo rt;
     rt.tone = (quint16)ui->rptToneCombo->currentData().toUInt();
     rd.accessMode = rm;
-    emit setRptAccessMode(rd);
-    emit setTSQL(rt);
+    setRptAccessMode(rd);
+    queue->add(priorityImmediate,queueItem(funcTSQLFreq,QVariant::fromValue<toneInfo>(rt),false, rt.useSecondaryVFO));
     bool updateSub = ui->setSplitRptrToneChk->isEnabled() && ui->setSplitRptrToneChk->isChecked();
 
     if(updateSub)
     {
         rd.useSecondaryVFO = true;
         rt.useSecondaryVFO = true;
-        emit setRptAccessMode(rd);
-        emit setTSQL(rt);
+        setRptAccessMode(rd);
+        queue->add(priorityImmediate,queueItem(funcTSQLFreq,QVariant::fromValue<toneInfo>(rt),false, rt.useSecondaryVFO));
     }
 }
 
@@ -622,12 +551,12 @@ void repeaterSetup::on_toneDTCS_clicked()
     rptrAccessData rd;
 
     rd.accessMode = ratrDD;
-    emit setRptAccessMode(rd);
+    setRptAccessMode(rd);
     toneInfo tone;
     tone.tinv = ui->rptDTCSInvertTx->isChecked();
     tone.rinv = ui->rptDTCSInvertRx->isChecked();
     tone.tone = (quint16)ui->rptDTCSCombo->currentData().toUInt();
-    emit setDTCS(tone);
+    queue->add(priorityImmediate,queueItem(funcRepeaterDTCS,QVariant::fromValue<toneInfo>(tone),false));
     // TODO: DTCS with subband
 }
 
@@ -721,8 +650,8 @@ void repeaterSetup::on_splitPlusButton_clicked()
         return;
     }
     if(ui->splitEnableChk->isChecked() || ui->quickSplitChk->isChecked()) {
-        emit setTransmitFrequency(f);
-        emit setTransmitMode(modeTransmitVFO);
+        queue->add(priorityImmediate,queueItem(funcSubFreq,QVariant::fromValue<freqt>(f),false));
+        queue->add(priorityImmediate,queueItem(funcModeSet,QVariant::fromValue<modeInfo>(modeTransmitVFO),false));
     } else {
         qWarning(logRptr()) << "Not setting transmit frequency until split mode is enabled.";
     }
@@ -753,8 +682,8 @@ void repeaterSetup::on_splitMinusBtn_clicked()
     }
 
     if(ui->splitEnableChk->isChecked() || ui->quickSplitChk->isChecked()) {
-        emit setTransmitFrequency(f);
-        emit setTransmitMode(modeTransmitVFO);
+        queue->add(priorityImmediate,queueItem(funcSubFreq,QVariant::fromValue<freqt>(f),false));
+        queue->add(priorityImmediate,queueItem(funcModeSet,QVariant::fromValue<modeInfo>(modeTransmitVFO),false));
     } else {
         qWarning(logRptr()) << "Not setting transmit frequency until split mode is enabled.";
         return;
@@ -774,8 +703,8 @@ void repeaterSetup::on_splitTxFreqSetBtn_clicked()
         f.Hz = fHz;
         f.VFO = inactiveVFO;
         f.MHzDouble = f.Hz/1E6;
-        emit setTransmitFrequency(f);
-        emit setTransmitMode(modeTransmitVFO);
+        queue->add(priorityImmediate,queueItem(funcSubFreq,QVariant::fromValue<freqt>(f),false));
+        queue->add(priorityImmediate,queueItem(funcModeSet,QVariant::fromValue<modeInfo>(modeTransmitVFO),false));
     }
 }
 
@@ -788,45 +717,45 @@ void repeaterSetup::on_splitTransmitFreqEdit_returnPressed()
 void repeaterSetup::on_selABtn_clicked()
 {
     vfo_t v = vfoA;
-    emit selectVFO(v);
+    queue->add(priorityImmediate,queueItem(funcSelectVFO,QVariant::fromValue<vfo_t>(v),false));
 }
 
 void repeaterSetup::on_selBBtn_clicked()
 {
     vfo_t v = vfoB;
-    emit selectVFO(v);
+    queue->add(priorityImmediate,queueItem(funcSelectVFO,QVariant::fromValue<vfo_t>(v),false));
 }
 
 void repeaterSetup::on_aEqBBtn_clicked()
 {
-    emit equalizeVFOsAB();
+    queue->add(priorityImmediate,funcVFOEqualAB,false,false);
 }
 
 void repeaterSetup::on_swapABBtn_clicked()
 {
-    emit swapVFOs();
+    queue->add(priorityImmediate,funcVFOSwapAB,false,false);
 }
 
 void repeaterSetup::on_selMainBtn_clicked()
 {
     vfo_t v = vfoMain;
-    emit selectVFO(v);
+    queue->add(priorityImmediate,queueItem(funcSelectVFO,QVariant::fromValue<vfo_t>(v),false));
 }
 
 void repeaterSetup::on_selSubBtn_clicked()
 {
     vfo_t v = vfoSub;
-    emit selectVFO(v);
+    queue->add(priorityImmediate,queueItem(funcSelectVFO,QVariant::fromValue<vfo_t>(v),false));
 }
 
 void repeaterSetup::on_mEqSBtn_clicked()
 {
-    emit equalizeVFOsMS();
+    queue->add(priorityImmediate,funcVFOEqualMS,false,false);
 }
 
 void repeaterSetup::on_swapMSBtn_clicked()
 {
-    emit swapVFOs();
+    queue->add(priorityImmediate,funcVFOSwapMS,false,false);
 }
 
 void repeaterSetup::on_setToneSubVFOBtn_clicked()
@@ -837,7 +766,7 @@ void repeaterSetup::on_setToneSubVFOBtn_clicked()
     toneInfo rt;
     rt.tone = (quint16)ui->rptToneCombo->currentData().toUInt();
     rt.useSecondaryVFO = true;
-    emit setTone(rt);
+    queue->add(priorityImmediate,queueItem(funcToneFreq,QVariant::fromValue<toneInfo>(rt),false, rt.useSecondaryVFO));
 }
 
 void repeaterSetup::on_setRptrSubVFOBtn_clicked()
@@ -856,7 +785,7 @@ void repeaterSetup::on_setRptrSubVFOBtn_clicked()
     if(ui->toneDTCS->isChecked())
         rd.accessMode=ratrDD;
 
-    emit setRptAccessMode(rd);
+    setRptAccessMode(rd);
 }
 
 void repeaterSetup::on_rptrOffsetSetBtn_clicked()
@@ -867,7 +796,7 @@ void repeaterSetup::on_rptrOffsetSetBtn_clicked()
     f.VFO=activeVFO;
     if(f.Hz != 0)
     {
-        emit setRptDuplexOffset(f);
+        queue->add(priorityImmediate,queueItem(funcSendFreqOffset,QVariant::fromValue<freqt>(f),false));
     }
     ui->rptrOffsetEdit->clearFocus();
 }
@@ -888,5 +817,101 @@ void repeaterSetup::on_setSplitRptrToneChk_clicked(bool checked)
 
 void repeaterSetup::on_quickSplitChk_clicked(bool checked)
 {
-    emit setQuickSplit(checked);
+    queue->add(priorityImmediate,queueItem(funcQuickSplit,QVariant::fromValue<bool>(checked),false));
+}
+
+void repeaterSetup::receiveRigCaps(rigCapabilities* rig)
+{
+    this->rigCaps = rig;
+    if (rig != Q_NULLPTR)
+    {
+        qInfo() << "Got rigcaps for:" << rig->modelName;
+
+        if(rig->commands.contains(funcRepeaterTone)) {
+            ui->rptToneCombo->setDisabled(false);
+            ui->toneTone->setDisabled(false);
+        } else {
+            ui->rptToneCombo->setDisabled(true);
+            ui->toneTone->setDisabled(true);
+        }
+
+        if(rig->commands.contains(funcRepeaterTSQL)) {
+            ui->toneTSQL->setDisabled(false);
+        } else {
+            ui->toneTSQL->setDisabled(true);
+        }
+
+        if(rig->commands.contains(funcToneSquelchType))
+        {
+            ui->rptToneCombo->setDisabled(false);
+            ui->toneTone->setDisabled(false);
+            ui->toneTSQL->setDisabled(false);
+        }
+
+        if(rig->commands.contains(funcRepeaterDTCS))
+        {
+            ui->rptDTCSCombo->setDisabled(false);
+            ui->toneDTCS->setDisabled(false);
+            ui->rptDTCSInvertRx->setDisabled(false);
+            ui->rptDTCSInvertTx->setDisabled(false);
+        } else {
+            ui->rptDTCSCombo->setDisabled(true);
+            ui->toneDTCS->setDisabled(true);
+            ui->rptDTCSInvertRx->setDisabled(true);
+            ui->rptDTCSInvertTx->setDisabled(true);
+        }
+        if(rig->commands.contains(funcVFOEqualAB))
+        {
+            ui->selABtn->setDisabled(false);
+            ui->selBBtn->setDisabled(false);
+            ui->aEqBBtn->setDisabled(false);
+            ui->swapABBtn->setDisabled(false);
+        } else {
+            ui->selABtn->setDisabled(true);
+            ui->selBBtn->setDisabled(true);
+            ui->aEqBBtn->setDisabled(true);
+            ui->swapABBtn->setDisabled(true);
+        }
+        if(rig->commands.contains(funcVFOEqualMS))
+        {
+            ui->selMainBtn->setDisabled(false);
+            ui->selSubBtn->setDisabled(false);
+            ui->mEqSBtn->setDisabled(false);
+            ui->swapMSBtn->setDisabled(false);
+        } else {
+            ui->selMainBtn->setDisabled(true);
+            ui->selSubBtn->setDisabled(true);
+            ui->mEqSBtn->setDisabled(true);
+            ui->swapMSBtn->setDisabled(true);
+        }
+        if(rig->commands.contains(funcVFOEqualAB) && rig->commands.contains(funcVFOEqualMS))
+        {
+            // Rigs that have both AB and MS
+            // do not have a swap AB command.
+            //ui->swapABBtn->setDisabled(true);
+        }
+
+        bool mainSub = rig->commands.contains(funcVFOMainSelect);
+        if(mainSub)
+        {
+            ui->setRptrSubVFOBtn->setEnabled(true);
+            ui->setToneSubVFOBtn->setEnabled(true);
+            ui->setSplitRptrToneChk->setEnabled(true);
+        } else {
+            ui->setRptrSubVFOBtn->setDisabled(true);
+            ui->setToneSubVFOBtn->setDisabled(true);
+            ui->setSplitRptrToneChk->setDisabled(true);
+        }
+
+        bool rpt = rig->commands.contains(funcToneSquelchType);
+        ui->rptAutoBtn->setEnabled(rpt);
+        ui->rptDupMinusBtn->setEnabled(rpt);
+        ui->rptDupPlusBtn->setEnabled(rpt);
+        ui->rptSimplexBtn->setEnabled(rpt);
+        ui->rptrOffsetEdit->setEnabled(rpt);
+        ui->rptrOffsetSetBtn->setEnabled(rpt);
+        ui->setToneSubVFOBtn->setEnabled(mainSub);
+        ui->setRptrSubVFOBtn->setEnabled(mainSub);
+        ui->quickSplitChk->setVisible(rig->commands.contains(funcQuickSplit));
+    }
 }

repeatersetup.h

@@ -4,6 +4,7 @@
 #include <QMainWindow>
 #include <QDebug>
 
+#include "cachingqueue.h"
 #include "repeaterattributes.h"
 #include "rigidentities.h"
 #include "logcategories.h"
@@ -30,7 +31,6 @@ signals:
     void getTone();
     void getTSQL();
     void getDTCS();
-    void setRptAccessMode(rptrAccessData rd);
     void getRptAccessMode();
     void setRptDuplexOffset(freqt f);
     void getRptDuplexOffset();
@@ -60,6 +60,8 @@ public slots:
     void handleUpdateCurrentMainMode(modeInfo m);
     void handleTransmitStatus(bool amTransmitting);
     void handleRptOffsetFrequency(freqt f);
+    void receiveRigCaps(rigCapabilities* caps);
+
 
 private slots:
     void showEvent(QShowEvent *event);
@@ -101,6 +103,7 @@ private:
     void populateDTCS();
     quint64 getFreqHzFromKHzString(QString khz);
     quint64 getFreqHzFromMHzString(QString MHz);
+    void setRptAccessMode(rptrAccessData rd);
 
     rigCapabilities rig;
     bool haveRig = false;
@@ -111,6 +114,8 @@ private:
     freqt currentOffset;
     bool usedPlusSplit = false;
     bool amTransmitting = false;
+    cachingQueue* queue = Q_NULLPTR;
+    rigCapabilities* rigCaps = Q_NULLPTR;
 };
 
 #endif // REPEATERSETUP_H

rigcommander.cpp

@@ -317,7 +317,7 @@ void rigCommander::prepDataAndSend(QByteArray data)
     emit dataForComm(data);
 }
 
-bool rigCommander::getCommand(funcs func, QByteArray &payload, int value, uchar vfo)
+bool rigCommander::getCommand(funcs func, QByteArray &payload, int value, uchar receiver)
 {
     // Value is set to INT_MIN by default as this should be outside any "real" values
     auto it = rigCaps.commands.find(func);
@@ -335,12 +335,12 @@ bool rigCommander::getCommand(funcs func, QByteArray &payload, int value, uchar
             {
                 // This can use cmd29 so add sub/main to the command
                 payload.append('\x29');
-                payload.append(static_cast<uchar>(vfo));
-            } else if (!rigCaps.hasCommand29 && vfo)
+                payload.append(static_cast<uchar>(receiver));
+            } else if (!rigCaps.hasCommand29 && receiver)
             {
                 // We don't have command29 so can't select sub
-                qInfo(logRig()) << "Rig has no Command29, removing command:" << funcString[func] << "VFO" << vfo;
-                queue->del(func,vfo);
+                qInfo(logRig()) << "Rig has no Command29, removing command:" << funcString[func] << "VFO" << receiver;
+                queue->del(func,receiver);
                 return false;
             }
             payload.append(it.value().data);
@@ -352,8 +352,8 @@ bool rigCommander::getCommand(funcs func, QByteArray &payload, int value, uchar
         }
     } else {
         // Don't try this command again as the rig doesn't support it!
-        qDebug(logRig()) << "Removing unsupported command from queue" << funcString[func] << "VFO" << vfo;
-        queue->del(func,vfo);
+        qDebug(logRig()) << "Removing unsupported command from queue" << funcString[func] << "VFO" << receiver;
+        queue->del(func,receiver);
     }
     return false;
 }
@@ -702,7 +702,7 @@ void rigCommander::parseCommand()
 #endif
 
     funcs func = funcNone;
-    uchar vfo = 0;
+    uchar receiver = 0;
 
     if (payloadIn.endsWith((char)0xfd))
     {
@@ -711,7 +711,7 @@ void rigCommander::parseCommand()
 
     if (rigCaps.hasCommand29 && payloadIn[0] == '\x29')
     {
-        vfo = static_cast<uchar>(payloadIn[1]);
+        receiver = static_cast<uchar>(payloadIn[1]);
         payloadIn.remove(0,2);
     }
 
@@ -746,15 +746,9 @@ void rigCommander::parseCommand()
     freqt test;
     QVector<memParserFormat> memParser;
     QVariant value;
+    uchar vfo=0; // Used for second VFO
     switch (func)
     {
-    case funcFreqGet:
-    case funcFreqTR:
-    case funcReadTXFreq:
-    {
-        value.setValue(parseFreqData(payloadIn,vfo));
-        break;
-    }
     case funcVFODualWatch:
         value.setValue(static_cast<bool>(bool(payloadIn[0])));
         break;
@@ -762,19 +756,28 @@ void rigCommander::parseCommand()
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
 #endif
+    case funcSubFreq:
+        receiver = 1;
     case funcUnselectedFreq:
-        vfo = 1;
+        if (func == funcUnselectedFreq)
+            vfo=1;
     case funcSelectedFreq:
+    case funcMainFreq:
+    case funcFreqGet:
+    case funcFreqTR:
+    case funcReadTXFreq:
     {
-        //qInfo(logRig()) << "Freq len:" << payloadIn.size() << "VFO=" << vfo << "data:" << payloadIn.toHex(' ');
         value.setValue(parseFreqData(payloadIn,vfo));
+        //qInfo(logRig()) << funcString[func] << "len:" << payloadIn.size() << "receiver=" << receiver << "vfo=" << vfo <<
+        //    "value:" << value.value<freqt>().Hz << "data:" << payloadIn.toHex(' ');
+
         break;
     }
     case funcModeGet:
     case funcModeTR:
     {
         modeInfo m;
-        m = parseMode(payloadIn[0], m.filter,vfo);
+        m = parseMode(payloadIn[0], m.filter,receiver);
 
         if(payloadIn.size() > 1)
         {
@@ -785,15 +788,17 @@ void rigCommander::parseCommand()
         value.setValue(m);
         break;
     }
-    case funcUnselectedMode:
-        vfo = 1;
+    case funcSubMode:
+        receiver = 1;
     case funcSelectedMode:
+    case funcUnselectedMode:
+    case funcMainMode:
     {
         modeInfo m;
         // New format payload with mode+datamode+filter
-        m = parseMode(bcdHexToUChar(payloadIn[0]), bcdHexToUChar(payloadIn[2]),vfo);
+        m = parseMode(bcdHexToUChar(payloadIn[0]), bcdHexToUChar(payloadIn[2]),receiver);
         m.data = bcdHexToUChar(payloadIn[1]);
-        m.VFO = selVFO_t(vfo);
+        m.VFO = selVFO_t(receiver);
         value.setValue(m);
         break;
     }
@@ -829,7 +834,7 @@ void rigCommander::parseCommand()
     case funcScanning:
         break;
     case funcReadFreqOffset:
-        value.setValue(parseFreqData(payloadIn,vfo));
+        value.setValue(parseFreqData(payloadIn,receiver));
         break;
     // These return a single byte that we convert to a uchar (0-99)
     case funcTuningStep:
@@ -965,7 +970,7 @@ void rigCommander::parseCommand()
         if (rigCaps.modelID == 0xAC && bsr.band == 6) {
             freqLen = 6;
         }
-        bsr.freq = parseFreqData(payloadIn.mid(2,freqLen),vfo);
+        bsr.freq = parseFreqData(payloadIn.mid(2,freqLen),receiver);
         // The Band Stacking command returns the regCode in the position that VFO is expected.
         // As BSR is always on the active VFO, just set that.
         bsr.freq.VFO = selVFO_t::activeVFO;
@@ -982,7 +987,7 @@ void rigCommander::parseCommand()
         quint16 calc;
         quint8 pass = bcdHexToUChar((quint8)payloadIn[0]);
         modeInfo m;
-        m = queue->getCache((vfo?funcUnselectedMode:funcSelectedMode),vfo).value.value<modeInfo>();
+        m = queue->getCache((receiver?funcSubMode:funcMainMode),receiver).value.value<modeInfo>();
 
         if (m.mk == modeAM)
         {
@@ -996,16 +1001,16 @@ void rigCommander::parseCommand()
              calc = 600 + ((pass - 10) * 100);
         }
         value.setValue(calc);
-        //qInfo() << "Got filter width" << calc << "VFO" << vfo;
+        //qInfo() << "Got filter width" << calc << "VFO" << receiver;
         break;
     }
     case funcDataModeWithFilter:
     {
         modeInfo m;
         // New format payload with mode+datamode+filter
-        m = parseMode(uchar(payloadIn[0]), uchar(payloadIn[2]),vfo);
+        m = parseMode(uchar(payloadIn[0]), uchar(payloadIn[2]),receiver);
         m.data = uchar(payloadIn[1]);
-        m.VFO = selVFO_t(vfo & 0x01);
+        m.VFO = selVFO_t(receiver & 0x01);
         value.setValue(m);
         break;
     }
@@ -1078,7 +1083,7 @@ void rigCommander::parseCommand()
     case funcScopeMainWaveData:
     {
         scopeData d;
-        if (parseSpectrum(d,vfo))
+        if (parseSpectrum(d,receiver))
             value.setValue(d);
         break;
     }
@@ -1090,7 +1095,7 @@ void rigCommander::parseCommand()
         // This tells us whether we are receiving main or sub data
     case funcScopeSingleDual:
         // This tells us whether we are receiving single or dual scopes
-        //qInfo(logRig()) << "funcScopeSingleDual (" << vfo <<") " << static_cast<bool>(payloadIn[0]);
+        //qInfo(logRig()) << "funcScopeSingleDual (" << receiver <<") " << static_cast<bool>(payloadIn[0]);
         value.setValue(static_cast<bool>(payloadIn[0]));
         break;
 #if defined __GNUC__
@@ -1098,7 +1103,7 @@ void rigCommander::parseCommand()
 #pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
 #endif
     case funcScopeSubMode:
-        vfo=1;
+        receiver=1;
     case funcScopeMainMode:
         // fixed or center
         // [1] 0x14
@@ -1107,7 +1112,7 @@ void rigCommander::parseCommand()
         value.setValue(static_cast<spectrumMode_t>(uchar(payloadIn[0])));
         break;
     case funcScopeSubSpan:
-        vfo=1;
+        receiver=1;
     case funcScopeMainSpan:
     {
         freqt f = parseFrequency(payloadIn, 3);
@@ -1121,7 +1126,7 @@ void rigCommander::parseCommand()
         break;
     }
     case funcScopeSubEdge:
-        vfo=1;
+        receiver=1;
     case funcScopeMainEdge:
         // read edge mode center in edge mode
         // [1] 0x16
@@ -1130,12 +1135,12 @@ void rigCommander::parseCommand()
         //emit haveScopeEdge((char)payloadIn[2]);
         break;
     case funcScopeSubHold:
-        vfo=1;
+        receiver=1;
     case funcScopeMainHold:
         value.setValue(static_cast<bool>(payloadIn[0]));
         break;
     case funcScopeSubRef:
-        vfo=1;
+        receiver=1;
     case funcScopeMainRef:
     {
         // scope reference level
@@ -1154,16 +1159,16 @@ void rigCommander::parseCommand()
         break;
     }
     case funcScopeSubSpeed:
-        vfo=1;
+        receiver=1;
     case funcScopeMainSpeed:
         value.setValue(static_cast<uchar>(payloadIn[0]));
         break;
     case funcScopeSubVBW:
-        vfo=1;
+        receiver=1;
     case funcScopeMainVBW:
         break;
     case funcScopeSubRBW:
-        vfo=1;
+        receiver=1;
     case funcScopeMainRBW:
         break;
 #if defined __GNUC__
@@ -1235,7 +1240,7 @@ void rigCommander::parseCommand()
 #endif
 
     if (value.isValid() && queue != Q_NULLPTR) {
-        queue->receiveValue(func,value,vfo);
+        queue->receiveValue(func,value,receiver);
     }
 
 }
@@ -1284,6 +1289,7 @@ void rigCommander::determineRigCaps()
     rigCaps.modelName = settings->value("Model", "").toString();
     qInfo(logRig()) << QString("Loading Rig: %0 from %1").arg(rigCaps.modelName,rigCaps.filename);
 
+    rigCaps.numReceiver = settings->value("NumberOfReceivers",1).toUInt();
     rigCaps.numVFO = settings->value("NumberOfVFOs",1).toUInt();
     rigCaps.spectSeqMax = settings->value("SpectrumSeqMax",0).toUInt();
     rigCaps.spectAmpMax = settings->value("SpectrumAmpMax",0).toUInt();
@@ -1563,7 +1569,7 @@ void rigCommander::determineRigCaps()
     }
 }
 
-bool rigCommander::parseSpectrum(scopeData& d, uchar vfo)
+bool rigCommander::parseSpectrum(scopeData& d, uchar receiver)
 {
     bool ret = false;
 
@@ -1579,7 +1585,7 @@ bool rigCommander::parseSpectrum(scopeData& d, uchar vfo)
         return ret;
     }
 
-    if (vfo)
+    if (receiver)
         d = subScopeData;
     else
         d = mainScopeData;
@@ -1619,7 +1625,7 @@ bool rigCommander::parseSpectrum(scopeData& d, uchar vfo)
     freqt fStart;
     freqt fEnd;
 
-    d.vfo = vfo;
+    d.receiver = receiver;
     unsigned char sequence = bcdHexToUChar(payloadIn[0]);
     unsigned char sequenceMax = bcdHexToUChar(payloadIn[1]);
 
@@ -1681,9 +1687,9 @@ bool rigCommander::parseSpectrum(scopeData& d, uchar vfo)
         d.data.clear();
 
         // For Fixed, and both scroll modes, the following produces correct information:
-        fStart = parseFreqData(payloadIn.mid(3,freqLen),vfo);
+        fStart = parseFreqData(payloadIn.mid(3,freqLen),receiver);
         d.startFreq = fStart.MHzDouble;
-        fEnd = parseFreqData(payloadIn.mid(3+freqLen,freqLen),vfo);
+        fEnd = parseFreqData(payloadIn.mid(3+freqLen,freqLen),receiver);
         d.endFreq = fEnd.MHzDouble;
 
         if(d.mode == spectModeCenter)
@@ -1719,7 +1725,7 @@ bool rigCommander::parseSpectrum(scopeData& d, uchar vfo)
 
     if (!ret) {
         // We need to temporarilly store the scope data somewhere.
-        if (vfo)
+        if (receiver)
             subScopeData = d;
         else
             mainScopeData = d;
@@ -1954,12 +1960,13 @@ freqt rigCommander::parseFrequency(QByteArray data, unsigned char lastPosition)
 }
 
 
-freqt rigCommander::parseFreqData(QByteArray data, uchar vfo)
+freqt rigCommander::parseFreqData(QByteArray data, uchar receiver)
 {
     freqt freq;
     freq.Hz = parseFreqDataToInt(data);
     freq.MHzDouble = freq.Hz/1000000.0;
-    freq.VFO = selVFO_t(vfo);
+    freq.VFO = selVFO_t(receiver);
+    //qInfo(logRig()) << "Received Frequency" << freq.Hz << "vfo" << receiver;
     return freq;
 }
 
@@ -1979,7 +1986,7 @@ quint64 rigCommander::parseFreqDataToInt(QByteArray data)
 }
 
 
-modeInfo rigCommander::parseMode(quint8 mode, quint8 filter, uchar vfo)
+modeInfo rigCommander::parseMode(quint8 mode, quint8 filter, uchar receiver)
 {
     modeInfo mi;
     bool found=false;
@@ -2000,13 +2007,13 @@ modeInfo rigCommander::parseMode(quint8 mode, quint8 filter, uchar vfo)
 
     // We cannot query sub VFO width without command29.
     if (!rigCaps.hasCommand29)
-        vfo = 0;
+        receiver = 0;
 
     cacheItem item;
 
     // Does the current mode support filterwidth?
     if (mi.bwMin >0  && mi.bwMax > 0) {
-        queue->getCache(funcFilterWidth,vfo);
+        queue->getCache(funcFilterWidth,receiver);
     }
 
     if (item.value.isValid()) {
@@ -2391,10 +2398,10 @@ quint8* rigCommander::getGUID() {
     return guid;
 }
 
-uchar rigCommander::makeFilterWidth(ushort pass,uchar vfo)
+uchar rigCommander::makeFilterWidth(ushort pass,uchar receiver)
 {
     unsigned char calc;
-    modeInfo mi = queue->getCache((vfo==1?funcUnselectedMode:funcSelectedMode),vfo).value.value<modeInfo>();
+    modeInfo mi = queue->getCache((receiver==1?funcSubMode:funcMainMode),receiver).value.value<modeInfo>();
     if (mi.mk == modeAM) { // AM 0-49
 
         calc = quint16((pass / 200) - 1);
@@ -2424,7 +2431,7 @@ uchar rigCommander::makeFilterWidth(ushort pass,uchar vfo)
     return b1;
 }
 
-void rigCommander::receiveCommand(funcs func, QVariant value, uchar vfo)
+void rigCommander::receiveCommand(funcs func, QVariant value, uchar receiver)
 {
     //qInfo() << "Got command:" << funcString[func];
     int val=INT_MIN;
@@ -2454,28 +2461,31 @@ void rigCommander::receiveCommand(funcs func, QVariant value, uchar vfo)
     }
 
     // Need to work out what to do with older dual-VFO rigs.
-    if ((func == funcSelectedFreq || func == funcUnselectedFreq) && !rigCaps.commands.contains(func))
+    /*
+    if ((func == funcMainFreq || func == funcSubFreq) && !rigCaps.commands.contains(func))
     {
         if (value.isValid())
             func = funcFreqSet;
         else
             func = funcFreqGet;
-    } else if ((func == funcSelectedMode || func == funcUnselectedMode) && !rigCaps.commands.contains(func))
+    } else if ((func == funcMainMode || func == funcSubMode) && !rigCaps.commands.contains(func))
     {
         if (value.isValid())
             func = funcModeSet;
         else
             func = funcModeGet;
-    } else if (func == funcSelectVFO) {
+    } else
+    */
+    if (func == funcSelectVFO) {
         // Special command
         vfo_t v = value.value<vfo_t>();
-        func = (v == vfoA)?funcVFOASelect:(v == vfoB)?funcVFOBSelect:(v == vfoMain)?funcVFOMainSelect:funcVFOSubSelect;
+        func = (v == vfoA)?funcVFOASelect:(v == vfoB)?funcVFOBSelect:(v = vfoMain)?funcVFOMainSelect:funcVFOSubSelect;
         value.clear();
         val = INT_MIN;
     }
 
     QByteArray payload;
-    if (getCommand(func,payload,val,vfo))
+    if (getCommand(func,payload,val,receiver))
     {
         if (value.isValid())
         {
@@ -2520,8 +2530,8 @@ void rigCommander::receiveCommand(funcs func, QVariant value, uchar vfo)
             else if (!strcmp(value.typeName(),"ushort"))
             {
                  if (func == funcFilterWidth) {
-                    payload.append(makeFilterWidth(value.value<ushort>(),vfo));
-                    //qInfo() << "Setting filter width" << value.value<ushort>() << "VFO" << vfo << "hex" << payload.toHex();
+                    payload.append(makeFilterWidth(value.value<ushort>(),receiver));
+                    //qInfo() << "Setting filter width" << value.value<ushort>() << "VFO" << receiver << "hex" << payload.toHex();
 
                 }
                 else if (func == funcKeySpeed){
@@ -2775,7 +2785,7 @@ void rigCommander::receiveCommand(funcs func, QVariant value, uchar vfo)
                        payload.append(value.value<modeInfo>().filter);
                 } else {
                     payload.append(bcdEncodeChar(value.value<modeInfo>().reg));
-                    if (func == funcSelectedMode || func == funcUnselectedMode)
+                    if (func == funcMainMode || func == funcSubMode || func == funcSelectedMode || func == funcUnselectedMode)
                        payload.append(value.value<modeInfo>().data);
                     payload.append(value.value<modeInfo>().filter);
                 }
@@ -2848,7 +2858,7 @@ void rigCommander::receiveCommand(funcs func, QVariant value, uchar vfo)
             // will fail on some commands so they would need to be added here:
             if (func != funcScopeFixedEdgeFreq && func != funcSpeech && func != funcBandStackReg && func != funcMemoryContents && func != funcSendCW)
             {
-                queue->addUnique(priorityImmediate,func,false,vfo);
+                queue->addUnique(priorityImmediate,func,false,receiver);
             }
         }
         prepDataAndSend(payload);

rigcommander.h

@@ -74,7 +74,7 @@ public slots:
     void radioUsage(quint8 radio, bool admin, quint8 busy, QString name, QString ip);
     void setCurrentRadio(quint8 radio);
     void getDebug();
-    void receiveCommand(funcs func, QVariant value, uchar vfo);
+    void receiveCommand(funcs func, QVariant value, uchar receiver);
     void setAfGain(unsigned char level);
 
 signals:
@@ -139,7 +139,7 @@ private:
     freqt parseFrequency();
     freqt parseFrequency(QByteArray data, unsigned char lastPosition); // supply index where Mhz is found
 
-    freqt parseFreqData(QByteArray data, uchar vfo);
+    freqt parseFreqData(QByteArray data, uchar receiver);
     quint64 parseFreqDataToInt(QByteArray data);
     freqt parseFrequencyRptOffset(QByteArray data);
     bool parseMemory(QVector<memParserFormat>* memParser, memoryType* mem);
@@ -151,7 +151,7 @@ private:
 
     toneInfo decodeTone(QByteArray eTone);
     //quint16 decodeTone(QByteArray eTone, bool &tinv, bool &rinv);
-    uchar makeFilterWidth(ushort width, uchar vfo);
+    uchar makeFilterWidth(ushort width, uchar receiver);
 
 
     unsigned char audioLevelRxMean[50];
@@ -159,9 +159,9 @@ private:
     unsigned char audioLevelTxMean[50];
     unsigned char audioLevelTxPeak[50];
 
-    modeInfo parseMode(quint8 mode, quint8 filter, uchar vfo);
-    bool parseSpectrum(scopeData& d, uchar vfo);
-    bool getCommand(funcs func, QByteArray& payload, int value=INT_MIN, uchar vfo=0);
+    modeInfo parseMode(quint8 mode, quint8 filter, uchar receiver);
+    bool parseSpectrum(scopeData& d, uchar receiver);
+    bool getCommand(funcs func, QByteArray& payload, int value=INT_MIN, uchar receiver=0);
 
     QByteArray getLANAddr();
     QByteArray getUSBAddr();

rigcreator.cpp

@@ -141,6 +141,7 @@ void rigCreator::loadRigFile(QString file)
     ui->model->setText(settings->value("Model","").toString());
     ui->civAddress->setText(QString("%1").arg(settings->value("CIVAddress",0).toInt(),2,16));
     ui->rigctldModel->setText(settings->value("RigCtlDModel","").toString());
+    ui->numReceiver->setText(settings->value("NumberOfReceivers","1").toString());
     ui->numVFO->setText(settings->value("NumberOfVFOs","1").toString());
     ui->seqMax->setText(settings->value("SpectrumSeqMax","").toString());
     ui->ampMax->setText(settings->value("SpectrumAmpMax","").toString());
@@ -209,12 +210,11 @@ void rigCreator::loadRigFile(QString file)
             ui->periodicCommands->insertRow(ui->periodicCommands->rowCount());
             ui->periodicCommands->model()->setData(ui->periodicCommands->model()->index(c,0),p.priority);
             ui->periodicCommands->model()->setData(ui->periodicCommands->model()->index(c,1),funcString[p.func]);
-            ui->periodicCommands->model()->setData(ui->periodicCommands->model()->index(c,2),QString::number(p.vfo));
+            ui->periodicCommands->model()->setData(ui->periodicCommands->model()->index(c,2),QString::number(p.receiver));
             c++;
         }
     }
-    else {
-        for (int c = 0; c < numPeriodic; c++)
+    else { for (int c = 0; c < numPeriodic; c++)
         {
             settings->setArrayIndex(c);
             ui->periodicCommands->insertRow(ui->periodicCommands->rowCount());
@@ -275,8 +275,8 @@ void rigCreator::loadRigFile(QString file)
             ui->bands->insertRow(ui->bands->rowCount());
             ui->bands->model()->setData(ui->bands->model()->index(c,0),QString::number(settings->value("Num", 0).toUInt()).rightJustified(2,'0'));
             ui->bands->model()->setData(ui->bands->model()->index(c,1),QString::number(settings->value("BSR", 0).toUInt()).rightJustified(2,'0'));
-            ui->bands->model()->setData(ui->bands->model()->index(c,2),settings->value("Start", 0ULL).toInt(),Qt::DisplayRole);
-            ui->bands->model()->setData(ui->bands->model()->index(c,3),settings->value("End", 0ULL).toInt(),Qt::DisplayRole);
+            ui->bands->model()->setData(ui->bands->model()->index(c,2),settings->value("Start", 0ULL).toString(),Qt::DisplayRole);
+            ui->bands->model()->setData(ui->bands->model()->index(c,3),settings->value("End", 0ULL).toString(),Qt::DisplayRole);
             ui->bands->model()->setData(ui->bands->model()->index(c,4),settings->value("Range", 0.0).toString());
             ui->bands->model()->setData(ui->bands->model()->index(c,5),settings->value("MemoryGroup", -1).toString());
             ui->bands->model()->setData(ui->bands->model()->index(c,6),settings->value("Name", "").toString());
@@ -403,6 +403,8 @@ void rigCreator::loadRigFile(QString file)
     connect(ui->modes,SIGNAL(cellChanged(int,int)),SLOT(changed()));
     connect(ui->preamps,SIGNAL(cellChanged(int,int)),SLOT(changed()));
     connect(ui->spans,SIGNAL(cellChanged(int,int)),SLOT(changed()));
+    connect(ui->periodicCommands,SIGNAL(cellChanged(int,int)),SLOT(changed()));
+
     connect(ui->hasCommand29,SIGNAL(stateChanged(int)),SLOT(changed()));
     connect(ui->hasEthernet,SIGNAL(stateChanged(int)),SLOT(changed()));
     connect(ui->hasFDComms,SIGNAL(stateChanged(int)),SLOT(changed()));
@@ -410,6 +412,7 @@ void rigCreator::loadRigFile(QString file)
     connect(ui->hasSpectrum,SIGNAL(stateChanged(int)),SLOT(changed()));
     connect(ui->hasTransmit,SIGNAL(stateChanged(int)),SLOT(changed()));
     connect(ui->hasWifi,SIGNAL(stateChanged(int)),SLOT(changed()));
+
     connect(ui->civAddress,SIGNAL(editingFinished()),SLOT(changed()));
     connect(ui->rigctldModel,SIGNAL(editingFinished()),SLOT(changed()));
     connect(ui->model,SIGNAL(editingFinished()),SLOT(changed()));
@@ -420,7 +423,6 @@ void rigCreator::loadRigFile(QString file)
     connect(ui->memoryFormat,SIGNAL(editingFinished()),SLOT(changed()));
     connect(ui->satMemories,SIGNAL(editingFinished()),SLOT(changed()));
     connect(ui->satelliteFormat,SIGNAL(editingFinished()),SLOT(changed()));
-    connect(ui->periodicCommands,SIGNAL(editingFinished()),SLOT(changed()));
 
     settingsChanged = false;
 }
@@ -429,6 +431,7 @@ void rigCreator::changed()
 {
     settingsChanged = true;
 }
+
 void rigCreator::on_saveFile_clicked(bool clicked)
 {
     Q_UNUSED(clicked)
@@ -471,6 +474,7 @@ void rigCreator::saveRigFile(QString file)
     settings->setValue("Model",ui->model->text());
     settings->setValue("CIVAddress",ui->civAddress->text().toInt(nullptr,16));
     settings->setValue("RigCtlDModel",ui->rigctldModel->text().toInt());
+    settings->setValue("NumberOfReceivers",ui->numReceiver->text().toInt());
     settings->setValue("NumberOfVFOs",ui->numVFO->text().toInt());
     settings->setValue("SpectrumSeqMax",ui->seqMax->text().toInt());
     settings->setValue("SpectrumAmpMax",ui->ampMax->text().toInt());
@@ -525,7 +529,7 @@ void rigCreator::saveRigFile(QString file)
 
 
     //settings->remove("Spans");
-    ui->spans->sortByColumn(0,Qt::AscendingOrder);
+    ui->spans->sortByColumn(2,Qt::AscendingOrder);
     settings->beginWriteArray("Spans");
     for (int n = 0; n<ui->spans->rowCount();n++)
     {

rigcreator.h

@@ -17,10 +17,10 @@
 
 
 inline QList<periodicType> defaultPeriodic = {
-    {funcSelectedFreq,"Medium",0},
-    {funcSelectedMode,"Medium",0},
-    {funcUnselectedFreq,"Medium",1},
-    {funcUnselectedMode,"Medium",1},
+    {funcMainFreq,"Medium",0},
+    {funcMainMode,"Medium",0},
+    {funcSubFreq,"Medium",1},
+    {funcSubMode,"Medium",1},
     {funcOverflowStatus,"Medium",0},
     {funcScopeMainMode,"Medium High",0},
     {funcScopeSubMode,"Medium High",1},

rigcreator.ui

@@ -7,7 +7,7 @@
     <x>0</x>
     <y>0</y>
     <width>1616</width>
-    <height>1012</height>
+    <height>1042</height>
    </rect>
   </property>
   <property name="sizePolicy">
@@ -1005,28 +1005,28 @@
      <layout class="QVBoxLayout" name="verticalLayout_13">
       <item>
        <layout class="QFormLayout" name="formLayout_2">
-        <item row="1" column="0">
+        <item row="2" column="0">
          <widget class="QLabel" name="label_4">
           <property name="text">
            <string>Seq Max</string>
           </property>
          </widget>
         </item>
-        <item row="3" column="0">
+        <item row="4" column="0">
          <widget class="QLabel" name="label_5">
           <property name="text">
            <string>Len Max</string>
           </property>
          </widget>
         </item>
-        <item row="2" column="0">
+        <item row="3" column="0">
          <widget class="QLabel" name="label_6">
           <property name="text">
            <string>Amp Max</string>
           </property>
          </widget>
         </item>
-        <item row="2" column="1">
+        <item row="3" column="1">
          <widget class="QLineEdit" name="ampMax">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
@@ -1045,7 +1045,7 @@
           </property>
          </widget>
         </item>
-        <item row="3" column="1">
+        <item row="4" column="1">
          <widget class="QLineEdit" name="lenMax">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
@@ -1064,7 +1064,7 @@
           </property>
          </widget>
         </item>
-        <item row="1" column="1">
+        <item row="2" column="1">
          <widget class="QLineEdit" name="seqMax">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
@@ -1092,11 +1092,31 @@
         <item row="0" column="0">
          <widget class="QLabel" name="label_14">
           <property name="text">
-           <string>Num VFO</string>
+           <string>Num RX</string>
           </property>
          </widget>
         </item>
         <item row="0" column="1">
+         <widget class="QLineEdit" name="numReceiver">
+          <property name="maximumSize">
+           <size>
+            <width>60</width>
+            <height>16777215</height>
+           </size>
+          </property>
+          <property name="text">
+           <string>1</string>
+          </property>
+         </widget>
+        </item>
+        <item row="1" column="0">
+         <widget class="QLabel" name="label_15">
+          <property name="text">
+           <string>VFO per RX</string>
+          </property>
+         </widget>
+        </item>
+        <item row="1" column="1">
          <widget class="QLineEdit" name="numVFO">
           <property name="maximumSize">
            <size>

rigctld.cpp

@@ -785,10 +785,10 @@ int rigCtlClient::getCommand(QStringList& response, bool extended, const command
     int ret = -RIG_EINVAL;
     funcs func;
     // Use selected/unselected mode/freq if available
-    if ((cmd.func == funcFreqGet || cmd.func == funcFreqSet) && rigCaps->commands.contains(funcSelectedFreq)) {
-        func = funcSelectedFreq;
-    } else if ((cmd.func == funcModeGet || cmd.func == funcModeSet) && rigCaps->commands.contains(funcSelectedMode)) {
-        func = funcSelectedMode;
+    if ((cmd.func == funcFreqGet || cmd.func == funcFreqSet) && rigCaps->commands.contains(funcMainFreq)) {
+        func = funcMainFreq;
+    } else if ((cmd.func == funcModeGet || cmd.func == funcModeSet) && rigCaps->commands.contains(funcMainMode)) {
+        func = funcMainMode;
     } else {
         func = cmd.func;
     }

rigidentities.h

@@ -211,6 +211,7 @@ struct rigCapabilities {
     quint8 spectSeqMax;
     quint16 spectAmpMax;
     quint16 spectLenMax;
+    quint8 numReceiver;
     quint8 numVFO;
 
     bool hasNB = false;

rigs/IC-7610.rig

@@ -6,7 +6,8 @@ Manufacturer=Icom
 Model=IC-7610
 CIVAddress=152
 RigCtlDModel=3078
-NumberOfVFOs=2
+NumberOfReceivers=2
+NumberOfVFOs=1
 SpectrumSeqMax=15
 SpectrumAmpMax=200
 SpectrumLenMax=689
@@ -563,22 +564,22 @@ Commands\108\String=\\x21\\x02
 Commands\108\Min=0
 Commands\108\Max=1
 Commands\108\Command29=false
-Commands\109\Type=Selected Freq
+Commands\109\Type=Main RX Frequency
 Commands\109\String=\\x25\\x00
 Commands\109\Min=0
 Commands\109\Max=0
 Commands\109\Command29=false
-Commands\110\Type=Unselected Freq
+Commands\110\Type=Sub RX Frequency
 Commands\110\String=\\x25\\x01
 Commands\110\Min=0
 Commands\110\Max=0
 Commands\110\Command29=false
-Commands\111\Type=Selected Mode
+Commands\111\Type=Main RX Mode
 Commands\111\String=\\x26\\x00
 Commands\111\Min=0
 Commands\111\Max=0
 Commands\111\Command29=false
-Commands\112\Type=Unselected Mode
+Commands\112\Type=Sub RX Mode
 Commands\112\String=\\x26\\x01
 Commands\112\Min=0
 Commands\112\Max=0
@@ -742,81 +743,81 @@ Periodic\5\VFO=0
 Periodic\6\Priority=Medium High
 Periodic\6\Command=DATA3 Mod Input
 Periodic\6\VFO=0
-Periodic\7\Priority=Medium Low
-Periodic\7\Command=Monitor Gain
+Periodic\7\Priority=Medium
+Periodic\7\Command=Main RX Frequency
 Periodic\7\VFO=0
-Periodic\8\Priority=Medium Low
-Periodic\8\Command=Monitor Status
+Periodic\8\Priority=Medium
+Periodic\8\Command=Main RX Mode
 Periodic\8\VFO=0
-Periodic\9\Priority=Medium
-Periodic\9\Command=Overflow Status
+Periodic\9\Priority=Medium Low
+Periodic\9\Command=Monitor Gain
 Periodic\9\VFO=0
 Periodic\10\Priority=Medium Low
-Periodic\10\Command=Preamp Status
-Periodic\10\VFO=-1
+Periodic\10\Command=Monitor Status
+Periodic\10\VFO=0
 Periodic\11\Priority=Medium
-Periodic\11\Command=RF Gain
+Periodic\11\Command=Overflow Status
 Periodic\11\VFO=0
-Periodic\12\Priority=Medium
-Periodic\12\Command=RF Power
-Periodic\12\VFO=0
-Periodic\13\Priority=Highest
-Periodic\13\Command=S Meter
-Periodic\13\VFO=-1
+Periodic\12\Priority=Medium Low
+Periodic\12\Command=Preamp Status
+Periodic\12\VFO=-1
+Periodic\13\Priority=Medium
+Periodic\13\Command=RF Gain
+Periodic\13\VFO=0
 Periodic\14\Priority=Medium
-Periodic\14\Command=Scope Main Hold
+Periodic\14\Command=RF Power
 Periodic\14\VFO=0
-Periodic\15\Priority=Medium High
-Periodic\15\Command=Scope Main Mode
-Periodic\15\VFO=0
-Periodic\16\Priority=Medium High
-Periodic\16\Command=Scope Main Span
+Periodic\15\Priority=Highest
+Periodic\15\Command=S Meter
+Periodic\15\VFO=-1
+Periodic\16\Priority=Medium
+Periodic\16\Command=Scope Main Hold
 Periodic\16\VFO=0
-Periodic\17\Priority=Medium
-Periodic\17\Command=Scope Main Speed
+Periodic\17\Priority=Medium High
+Periodic\17\Command=Scope Main Mode
 Periodic\17\VFO=0
 Periodic\18\Priority=Medium High
-Periodic\18\Command=Scope Main/Sub
+Periodic\18\Command=Scope Main Span
 Periodic\18\VFO=0
-Periodic\19\Priority=Medium High
-Periodic\19\Command=Scope Single/Dual
+Periodic\19\Priority=Medium
+Periodic\19\Command=Scope Main Speed
 Periodic\19\VFO=0
-Periodic\20\Priority=Medium
-Periodic\20\Command=Scope Sub Hold
-Periodic\20\VFO=1
+Periodic\20\Priority=Medium High
+Periodic\20\Command=Scope Main/Sub
+Periodic\20\VFO=0
 Periodic\21\Priority=Medium High
-Periodic\21\Command=Scope Sub Mode
-Periodic\21\VFO=1
-Periodic\22\Priority=Medium High
-Periodic\22\Command=Scope Sub Span
+Periodic\21\Command=Scope Single/Dual
+Periodic\21\VFO=0
+Periodic\22\Priority=Medium
+Periodic\22\Command=Scope Sub Hold
 Periodic\22\VFO=1
-Periodic\23\Priority=Medium
-Periodic\23\Command=Scope Sub Speed
+Periodic\23\Priority=Medium High
+Periodic\23\Command=Scope Sub Mode
 Periodic\23\VFO=1
-Periodic\24\Priority=Medium
-Periodic\24\Command=Selected Freq
-Periodic\24\VFO=0
+Periodic\24\Priority=Medium High
+Periodic\24\Command=Scope Sub Span
+Periodic\24\VFO=1
 Periodic\25\Priority=Medium
-Periodic\25\Command=Selected Mode
-Periodic\25\VFO=0
+Periodic\25\Command=Scope Sub Speed
+Periodic\25\VFO=1
 Periodic\26\Priority=Medium Low
 Periodic\26\Command=Squelch
 Periodic\26\VFO=0
-Periodic\27\Priority=High
-Periodic\27\Command=Transceiver Status
-Periodic\27\VFO=0
+Periodic\27\Priority=Medium
+Periodic\27\Command=Sub RX Frequency
+Periodic\27\VFO=1
 Periodic\28\Priority=Medium
-Periodic\28\Command=Tuner/ATU Status
-Periodic\28\VFO=0
-Periodic\29\Priority=Medium Low
-Periodic\29\Command=Tuning Step
+Periodic\28\Command=Sub RX Mode
+Periodic\28\VFO=1
+Periodic\29\Priority=High
+Periodic\29\Command=Transceiver Status
 Periodic\29\VFO=0
 Periodic\30\Priority=Medium
-Periodic\30\Command=Unselected Freq
-Periodic\30\VFO=1
-Periodic\31\Priority=Medium
-Periodic\31\Command=Unselected Mode
-Periodic\31\VFO=1
+Periodic\30\Command=Tuner/ATU Status
+Periodic\30\VFO=0
+Periodic\31\Priority=Medium Low
+Periodic\31\Command=Tuning Step
+Periodic\31\VFO=0
 Periodic\32\Priority=Medium
 Periodic\32\Command=VFO Dual Watch
 Periodic\32\VFO=0

rigs/IC-785x.rig

@@ -6,7 +6,8 @@ Manufacturer=Icom
 Model=IC-785x
 CIVAddress=142
 RigCtlDModel=3075
-NumberOfVFOs=2
+NumberOfReceivers=2
+NumberOfVFOs=1
 SpectrumSeqMax=15
 SpectrumAmpMax=200
 SpectrumLenMax=689
@@ -573,22 +574,22 @@ Commands\110\String=\\x21\\x02
 Commands\110\Min=0
 Commands\110\Max=1
 Commands\110\Command29=false
-Commands\111\Type=Selected Freq
+Commands\111\Type=Main RX Frequency
 Commands\111\String=\\x25\\x00
 Commands\111\Min=0
 Commands\111\Max=0
 Commands\111\Command29=false
-Commands\112\Type=Unselected Freq
+Commands\112\Type=Sub RX Frequency
 Commands\112\String=\\x25\\x01
 Commands\112\Min=0
 Commands\112\Max=0
 Commands\112\Command29=false
-Commands\113\Type=Selected Mode
+Commands\113\Type=Main RX Mode
 Commands\113\String=\\x26\\x00
 Commands\113\Min=0
 Commands\113\Max=0
 Commands\113\Command29=false
-Commands\114\Type=Unselected Mode
+Commands\114\Type=Sub RX Mode
 Commands\114\String=\\x26\\x01
 Commands\114\Min=0
 Commands\114\Max=0
@@ -752,84 +753,84 @@ Periodic\5\VFO=0
 Periodic\6\Priority=Medium High
 Periodic\6\Command=DATA3 Mod Input
 Periodic\6\VFO=0
-Periodic\7\Priority=Medium Low
-Periodic\7\Command=Monitor Gain
+Periodic\7\Priority=Medium
+Periodic\7\Command=Main RX Frequency
 Periodic\7\VFO=0
-Periodic\8\Priority=Medium Low
-Periodic\8\Command=Monitor Status
+Periodic\8\Priority=Medium
+Periodic\8\Command=Main RX Mode
 Periodic\8\VFO=0
-Periodic\9\Priority=Medium
-Periodic\9\Command=Overflow Status
+Periodic\9\Priority=Medium Low
+Periodic\9\Command=Monitor Gain
 Periodic\9\VFO=0
 Periodic\10\Priority=Medium Low
-Periodic\10\Command=Preamp Status
+Periodic\10\Command=Monitor Status
 Periodic\10\VFO=0
 Periodic\11\Priority=Medium
-Periodic\11\Command=RF Gain
+Periodic\11\Command=Overflow Status
 Periodic\11\VFO=0
-Periodic\12\Priority=Medium
-Periodic\12\Command=RF Power
+Periodic\12\Priority=Medium Low
+Periodic\12\Command=Preamp Status
 Periodic\12\VFO=0
-Periodic\13\Priority=Highest
-Periodic\13\Command=S Meter
+Periodic\13\Priority=Medium
+Periodic\13\Command=RF Gain
 Periodic\13\VFO=0
 Periodic\14\Priority=Medium
-Periodic\14\Command=Scope Main Hold
+Periodic\14\Command=RF Power
 Periodic\14\VFO=0
-Periodic\15\Priority=Medium High
-Periodic\15\Command=Scope Main Mode
+Periodic\15\Priority=Highest
+Periodic\15\Command=S Meter
 Periodic\15\VFO=0
-Periodic\16\Priority=Medium High
-Periodic\16\Command=Scope Main Span
+Periodic\16\Priority=Medium
+Periodic\16\Command=Scope Main Hold
 Periodic\16\VFO=0
-Periodic\17\Priority=Medium
-Periodic\17\Command=Scope Main Speed
+Periodic\17\Priority=Medium High
+Periodic\17\Command=Scope Main Mode
 Periodic\17\VFO=0
 Periodic\18\Priority=Medium High
-Periodic\18\Command=Scope Main/Sub
+Periodic\18\Command=Scope Main Span
 Periodic\18\VFO=0
-Periodic\19\Priority=Medium High
-Periodic\19\Command=Scope Single/Dual
+Periodic\19\Priority=Medium
+Periodic\19\Command=Scope Main Speed
 Periodic\19\VFO=0
-Periodic\20\Priority=Medium
-Periodic\20\Command=Scope Sub Hold
-Periodic\20\VFO=1
+Periodic\20\Priority=Medium High
+Periodic\20\Command=Scope Main/Sub
+Periodic\20\VFO=0
 Periodic\21\Priority=Medium High
-Periodic\21\Command=Scope Sub Mode
-Periodic\21\VFO=1
-Periodic\22\Priority=Medium High
-Periodic\22\Command=Scope Sub Span
+Periodic\21\Command=Scope Single/Dual
+Periodic\21\VFO=0
+Periodic\22\Priority=Medium
+Periodic\22\Command=Scope Sub Hold
 Periodic\22\VFO=1
-Periodic\23\Priority=Medium
-Periodic\23\Command=Scope Sub Speed
+Periodic\23\Priority=Medium High
+Periodic\23\Command=Scope Sub Mode
 Periodic\23\VFO=1
-Periodic\24\Priority=Medium
-Periodic\24\Command=Selected Freq
-Periodic\24\VFO=0
+Periodic\24\Priority=Medium High
+Periodic\24\Command=Scope Sub Span
+Periodic\24\VFO=1
 Periodic\25\Priority=Medium
-Periodic\25\Command=Selected Mode
-Periodic\25\VFO=0
+Periodic\25\Command=Scope Sub Speed
+Periodic\25\VFO=1
 Periodic\26\Priority=Medium Low
 Periodic\26\Command=Squelch
 Periodic\26\VFO=0
-Periodic\27\Priority=Medium Low
-Periodic\27\Command=Tone Squelch Type
-Periodic\27\VFO=0
-Periodic\28\Priority=High
-Periodic\28\Command=Transceiver Status
-Periodic\28\VFO=0
-Periodic\29\Priority=Medium
-Periodic\29\Command=Tuner/ATU Status
+Periodic\27\Priority=Medium
+Periodic\27\Command=Sub RX Frequency
+Periodic\27\VFO=1
+Periodic\28\Priority=Medium
+Periodic\28\Command=Sub RX Mode
+Periodic\28\VFO=1
+Periodic\29\Priority=Medium Low
+Periodic\29\Command=Tone Squelch Type
 Periodic\29\VFO=0
-Periodic\30\Priority=Medium Low
-Periodic\30\Command=Tuning Step
+Periodic\30\Priority=High
+Periodic\30\Command=Transceiver Status
 Periodic\30\VFO=0
 Periodic\31\Priority=Medium
-Periodic\31\Command=Unselected Freq
-Periodic\31\VFO=1
-Periodic\32\Priority=Medium
-Periodic\32\Command=Unselected Mode
-Periodic\32\VFO=1
+Periodic\31\Command=Tuner/ATU Status
+Periodic\31\VFO=0
+Periodic\32\Priority=Medium Low
+Periodic\32\Command=Tuning Step
+Periodic\32\VFO=0
 Periodic\33\Priority=Medium
 Periodic\33\Command=VFO Dual Watch
 Periodic\33\VFO=0

rigs/IC-905.rig

@@ -6,7 +6,8 @@ Manufacturer=Icom
 Model=IC-905
 CIVAddress=172
 RigCtlDModel=0
-NumberOfVFOs=1
+NumberOfReceivers=1
+NumberOfVFOs=2
 SpectrumSeqMax=11
 SpectrumAmpMax=160
 SpectrumLenMax=475
@@ -601,50 +602,50 @@ Periodic\20\Command=Tuning Step
 Periodic\20\VFO=-1
 Periodic\21\Priority=Medium
 Periodic\21\Command=Unselected Freq
-Periodic\21\VFO=1
+Periodic\21\VFO=0
 Periodic\22\Priority=Medium
 Periodic\22\Command=Unselected Mode
-Periodic\22\VFO=1
+Periodic\22\VFO=0
 Periodic\size=22
 Spans\1\Num=0
 Spans\1\Name=±2.5 KHz
 Spans\1\Freq=2500
-Spans\2\Num=0
-Spans\2\Name=±5 MHz
-Spans\2\Freq=5000000
-Spans\3\Num=0
-Spans\3\Name=±10 MHz
-Spans\3\Freq=10000000
-Spans\4\Num=0
-Spans\4\Name=±25 MHz
-Spans\4\Freq=25000000
-Spans\5\Num=1
-Spans\5\Name=±5 KHz
-Spans\5\Freq=5000
-Spans\6\Num=2
-Spans\6\Name=±10 KHz
-Spans\6\Freq=10000
-Spans\7\Num=3
-Spans\7\Name=±25 KHz
-Spans\7\Freq=25000
-Spans\8\Num=4
-Spans\8\Name=±50 KHz
-Spans\8\Freq=50000
-Spans\9\Num=5
-Spans\9\Name=±100 KHz
-Spans\9\Freq=100000
-Spans\10\Num=6
-Spans\10\Name=±250 KHz
-Spans\10\Freq=250000
-Spans\11\Num=7
-Spans\11\Name=±500 KHz
-Spans\11\Freq=500000
-Spans\12\Num=8
-Spans\12\Name=±1 MHz
-Spans\12\Freq=1000000
-Spans\13\Num=9
-Spans\13\Name=±2.5 MHz
-Spans\13\Freq=2500000
+Spans\2\Num=1
+Spans\2\Name=±5 KHz
+Spans\2\Freq=5000
+Spans\3\Num=2
+Spans\3\Name=±10 KHz
+Spans\3\Freq=10000
+Spans\4\Num=3
+Spans\4\Name=±25 KHz
+Spans\4\Freq=25000
+Spans\5\Num=4
+Spans\5\Name=±50 KHz
+Spans\5\Freq=50000
+Spans\6\Num=5
+Spans\6\Name=±100 KHz
+Spans\6\Freq=100000
+Spans\7\Num=6
+Spans\7\Name=±250 KHz
+Spans\7\Freq=250000
+Spans\8\Num=7
+Spans\8\Name=±500 KHz
+Spans\8\Freq=500000
+Spans\9\Num=8
+Spans\9\Name=±1 MHz
+Spans\9\Freq=1000000
+Spans\10\Num=9
+Spans\10\Name=±2.5 MHz
+Spans\10\Freq=2500000
+Spans\11\Num=0
+Spans\11\Name=±5 MHz
+Spans\11\Freq=5000000
+Spans\12\Num=0
+Spans\12\Name=±10 MHz
+Spans\12\Freq=10000000
+Spans\13\Num=0
+Spans\13\Name=±25 MHz
+Spans\13\Freq=25000000
 Spans\size=13
 Inputs\1\Num=0
 Inputs\1\Reg=0
@@ -667,22 +668,22 @@ Inputs\6\Name=M/A
 Inputs\size=6
 Bands\1\Num=0
 Bands\1\BSR=6
-Bands\1\Start=1410065408
-Bands\1\End=1910065408
+Bands\1\Start=10000000000
+Bands\1\End=10500000000
 Bands\1\Range=10500
 Bands\1\MemoryGroup=-1
 Bands\1\Name=3 cm
 Bands\2\Num=1
 Bands\2\BSR=5
-Bands\2\Start=1355032704
-Bands\2\End=1630032704
+Bands\2\Start=5650000000
+Bands\2\End=5925000000
 Bands\2\Range=5925
 Bands\2\MemoryGroup=-1
 Bands\2\Name=6 cm
 Bands\3\Num=3
 Bands\3\BSR=4
-Bands\3\Start=0
-Bands\3\End=0
+Bands\3\Start=2400000000
+Bands\3\End=2450000000
 Bands\3\Range=2450
 Bands\3\MemoryGroup=-1
 Bands\3\Name=13 cm

rigs/IC-9700.rig

@@ -6,7 +6,8 @@ Manufacturer=Icom
 Model=IC-9700
 CIVAddress=162
 RigCtlDModel=3081
-NumberOfVFOs=1
+NumberOfReceivers=2
+NumberOfVFOs=2
 SpectrumSeqMax=11
 SpectrumAmpMax=160
 SpectrumLenMax=475
@@ -553,87 +554,117 @@ Commands\106\String=\\x27\\x00\\x00
 Commands\106\Min=0
 Commands\106\Max=0
 Commands\106\Command29=false
-Commands\107\Type=Scope On/Off
-Commands\107\String=\\x27\\x10
+Commands\107\Type=Scope Sub Wave Data
+Commands\107\String=\\x27\\x00\\x01
 Commands\107\Min=0
-Commands\107\Max=1
+Commands\107\Max=0
 Commands\107\Command29=false
-Commands\108\Type=Scope Data Output
-Commands\108\String=\\x27\\x11
+Commands\108\Type=Scope On/Off
+Commands\108\String=\\x27\\x10
 Commands\108\Min=0
 Commands\108\Max=1
 Commands\108\Command29=false
-Commands\109\Type=Scope Main/Sub
-Commands\109\String=\\x27\\x12
+Commands\109\Type=Scope Data Output
+Commands\109\String=\\x27\\x11
 Commands\109\Min=0
 Commands\109\Max=1
 Commands\109\Command29=false
-Commands\110\Type=Scope Main Mode
-Commands\110\String=\\x27\\x14\\x00
+Commands\110\Type=Scope Main/Sub
+Commands\110\String=\\x27\\x12
 Commands\110\Min=0
-Commands\110\Max=3
+Commands\110\Max=1
 Commands\110\Command29=false
-Commands\111\Type=Scope Main Span
-Commands\111\String=\\x27\\x15\\x00
+Commands\111\Type=Scope Main Mode
+Commands\111\String=\\x27\\x14\\x00
 Commands\111\Min=0
-Commands\111\Max=7
+Commands\111\Max=3
 Commands\111\Command29=false
-Commands\112\Type=Scope Main Edge
-Commands\112\String=\\x27\\x16\\x00
-Commands\112\Min=1
-Commands\112\Max=4
+Commands\112\Type=Scope Sub Mode
+Commands\112\String=\\x27\\x14\\x01
+Commands\112\Min=0
+Commands\112\Max=3
 Commands\112\Command29=false
-Commands\113\Type=Scope Main Edge
-Commands\113\String=\\x27\\x17\\x00
+Commands\113\Type=Scope Main Span
+Commands\113\String=\\x27\\x15\\x00
 Commands\113\Min=0
-Commands\113\Max=1
+Commands\113\Max=7
 Commands\113\Command29=false
-Commands\114\Type=Scope Main Ref
-Commands\114\String=\\x27\\x19\\x00
+Commands\114\Type=Scope Sub Span
+Commands\114\String=\\x27\\x15\\x01
 Commands\114\Min=0
-Commands\114\Max=0
+Commands\114\Max=7
 Commands\114\Command29=false
-Commands\115\Type=Scope Main Speed
-Commands\115\String=\\x27\\x1a\\x00
-Commands\115\Min=0
-Commands\115\Max=2
+Commands\115\Type=Scope Main Edge
+Commands\115\String=\\x27\\x16\\x00
+Commands\115\Min=1
+Commands\115\Max=4
 Commands\115\Command29=false
-Commands\116\Type=Scope During TX
-Commands\116\String=\\x27\\x1b
-Commands\116\Min=0
-Commands\116\Max=1
+Commands\116\Type=Scope Sub Edge
+Commands\116\String=\\x27\\x16\\x01
+Commands\116\Min=1
+Commands\116\Max=4
 Commands\116\Command29=false
-Commands\117\Type=Scope Center Type
-Commands\117\String=\\x27\\x1c
+Commands\117\Type=Scope Main Ref
+Commands\117\String=\\x27\\x19\\x00
 Commands\117\Min=0
-Commands\117\Max=2
+Commands\117\Max=0
 Commands\117\Command29=false
-Commands\118\Type=Scope Main VBW
-Commands\118\String=\\x27\\x1d\\x00
+Commands\118\Type=Scope Sub Ref
+Commands\118\String=\\x27\\x19\\x01
 Commands\118\Min=0
-Commands\118\Max=1
+Commands\118\Max=0
 Commands\118\Command29=false
-Commands\119\Type=Scope Fixed Edge Freq
-Commands\119\String=\\x27\\x1e
-Commands\119\Min=1
-Commands\119\Max=0
+Commands\119\Type=Scope Main Speed
+Commands\119\String=\\x27\\x1a\\x00
+Commands\119\Min=0
+Commands\119\Max=2
 Commands\119\Command29=false
-Commands\120\Type=Voice TX
-Commands\120\String=\\x28\\x00
+Commands\120\Type=Scope Sub Speed
+Commands\120\String=\\x27\\x1a\\x01
 Commands\120\Min=0
-Commands\120\Max=8
+Commands\120\Max=2
 Commands\120\Command29=false
-Commands\121\Type=Command Error FA
-Commands\121\String=\\xfa
+Commands\121\Type=Scope During TX
+Commands\121\String=\\x27\\x1b
 Commands\121\Min=0
-Commands\121\Max=0
+Commands\121\Max=1
 Commands\121\Command29=false
-Commands\122\Type=Command OK FB
-Commands\122\String=\\xfb
+Commands\122\Type=Scope Center Type
+Commands\122\String=\\x27\\x1c
 Commands\122\Min=0
-Commands\122\Max=0
+Commands\122\Max=2
 Commands\122\Command29=false
-Commands\size=122
+Commands\123\Type=Scope Main VBW
+Commands\123\String=\\x27\\x1d\\x00
+Commands\123\Min=0
+Commands\123\Max=1
+Commands\123\Command29=false
+Commands\124\Type=Scope Sub VBW
+Commands\124\String=\\x27\\x1d\\x01
+Commands\124\Min=0
+Commands\124\Max=1
+Commands\124\Command29=false
+Commands\125\Type=Scope Fixed Edge Freq
+Commands\125\String=\\x27\\x1e
+Commands\125\Min=1
+Commands\125\Max=0
+Commands\125\Command29=false
+Commands\126\Type=Voice TX
+Commands\126\String=\\x28\\x00
+Commands\126\Min=0
+Commands\126\Max=8
+Commands\126\Command29=false
+Commands\127\Type=Command Error FA
+Commands\127\String=\\xfa
+Commands\127\Min=0
+Commands\127\Max=0
+Commands\127\Command29=false
+Commands\128\Type=Command OK FB
+Commands\128\String=\\xfb
+Commands\128\Min=0
+Commands\128\Max=0
+Commands\128\Command29=false
+Commands\size=128
 Periodic\1\Priority=Medium Low
 Periodic\1\Command=Attenuator Status
 Periodic\1\VFO=-1
@@ -696,10 +727,10 @@ Periodic\20\Command=Tuning Step
 Periodic\20\VFO=-1
 Periodic\21\Priority=Medium
 Periodic\21\Command=Unselected Freq
-Periodic\21\VFO=1
+Periodic\21\VFO=0
 Periodic\22\Priority=Medium
 Periodic\22\Command=Unselected Mode
-Periodic\22\VFO=1
+Periodic\22\VFO=0
 Periodic\23\Priority=Medium
 Periodic\23\Command=VFO Dual Watch
 Periodic\23\VFO=0

spectrumscope.cpp

@@ -2,8 +2,8 @@
 #include "logcategories.h"
 #include "rigidentities.h"
 
-spectrumScope::spectrumScope(QWidget *parent)
-    : QGroupBox{parent}
+spectrumScope::spectrumScope(uchar receiver, uchar vfo, QWidget *parent)
+    : QGroupBox{parent}, receiver(receiver), numVFO(vfo)
 {
 
     QMutexLocker locker(&mutex);
@@ -22,13 +22,33 @@ spectrumScope::spectrumScope(QWidget *parent)
 
     displayLayout = new QHBoxLayout();
 
-    freqDisplay = new freqCtrl();
-    freqDisplay->setMinimumSize(280,30);
-    freqDisplay->setMaximumSize(280,30);
+    for (uchar i=0;i<numVFO;i++)
+    {
+        qInfo() << "****Adding VFO" << i << "on receiver" << receiver;
+        freqDisplay[i] = new freqCtrl();
+        if (i==0)
+        {
+            freqDisplay[i]->setMinimumSize(280,30);
+            freqDisplay[i]->setMaximumSize(280,30);
+            displayLayout->addWidget(freqDisplay[i]);
+            displaySpacer = new QSpacerItem(0,0,QSizePolicy::Expanding,QSizePolicy::Fixed);
+            displayLayout->addSpacerItem(displaySpacer);
+        } else {
+            freqDisplay[i]->setMinimumSize(180,20);
+            freqDisplay[i]->setMaximumSize(180,20);
+            displayLayout->addWidget(freqDisplay[i]);
+        }
+        connect(this->freqDisplay[i], &freqCtrl::newFrequency, this,
+                [=](const qint64 &freq) { this->newFrequency(freq,i);});
+
+
+        //connect(this->rig, &rigCommander::haveDashRatio,
+        //        [=](const unsigned char& ratio) { cw->handleDashRatio(ratio); });
+
+        //connect(freqDisplay[i], SIGNAL(newFrequency(qint64)), this, SLOT(newFrequency(qint64,i)));
+
+    }
 
-    displayLayout->addWidget(freqDisplay);
-    displaySpacer = new QSpacerItem(0,0,QSizePolicy::Expanding,QSizePolicy::Fixed);
-    displayLayout->addSpacerItem(displaySpacer);
 
     controlLayout = new QHBoxLayout();
     detachButton = new QPushButton("Detach");
@@ -296,51 +316,51 @@ spectrumScope::spectrumScope(QWidget *parent)
 
     connect(configLength, &QSlider::valueChanged, this, [=](const int &val) {
         prepareWf(val);
-        emit updateSettings(vfo,currentTheme,wfLength,plotFloor,plotCeiling);
+        emit updateSettings(receiver,currentTheme,wfLength,plotFloor,plotCeiling);
     });
     connect(configBottom, &QSlider::valueChanged, this, [=](const int &val) {
         this->plotFloor = val;
         this->wfFloor = val;
         this->setRange(plotFloor,plotCeiling);
-        emit updateSettings(vfo,currentTheme,wfLength,plotFloor,plotCeiling);
+        emit updateSettings(receiver,currentTheme,wfLength,plotFloor,plotCeiling);
     });
     connect(configTop, &QSlider::valueChanged, this, [=](const int &val) {
         this->plotCeiling = val;
         this->wfCeiling = val;
         this->setRange(plotFloor,plotCeiling);
-        emit updateSettings(vfo,currentTheme,wfLength,plotFloor,plotCeiling);
+        emit updateSettings(receiver,currentTheme,wfLength,plotFloor,plotCeiling);
     });
 
     connect(configRef, &QSlider::valueChanged, this, [=](const int &val) {
         currentRef = (val/5) * 5; // rounded to "nearest 5"
-        queue->add(priorityImmediate,queueItem(vfo?funcScopeSubRef:funcScopeMainRef,QVariant::fromValue(currentRef),false,this->vfo));
+        queue->add(priorityImmediate,queueItem(receiver?funcScopeSubRef:funcScopeMainRef,QVariant::fromValue(currentRef),false,this->receiver));
     });
 
 
     connect(configSpeed, QOverload<int>::of(&QComboBox::currentIndexChanged), this, [=](const int &val) {
-        queue->add(priorityImmediate,queueItem(vfo?funcScopeSubSpeed:funcScopeMainSpeed,configSpeed->itemData(val),false,this->vfo));
+        queue->add(priorityImmediate,queueItem(receiver?funcScopeSubSpeed:funcScopeMainSpeed,configSpeed->itemData(val),false,this->receiver));
     });
 
     connect(configTheme, QOverload<int>::of(&QComboBox::currentIndexChanged), this, [=](const int &val) {
         Q_UNUSED(val)
         currentTheme = configTheme->currentData().value<QCPColorGradient::GradientPreset>();
         colorMap->setGradient(currentTheme);
-        emit updateSettings(vfo,currentTheme,wfLength,plotFloor,plotCeiling);
+        emit updateSettings(receiver,currentTheme,wfLength,plotFloor,plotCeiling);
     });
 
 
 
     connect(configPbtInner, &QSlider::valueChanged, this, [=](const int &val) {
-        queue->add(priorityImmediate,queueItem(funcPBTInner,QVariant::fromValue<ushort>(val),false,vfo));
+        queue->add(priorityImmediate,queueItem(funcPBTInner,QVariant::fromValue<ushort>(val),false,receiver));
     });
     connect(configPbtOuter, &QSlider::valueChanged, this, [=](const int &val) {
-        queue->add(priorityImmediate,queueItem(funcPBTInner,QVariant::fromValue<ushort>(val),false,vfo));
+        queue->add(priorityImmediate,queueItem(funcPBTInner,QVariant::fromValue<ushort>(val),false,receiver));
     });
     connect(configIfShift, &QSlider::valueChanged, this, [=](const int &val) {
-        queue->add(priorityImmediate,queueItem(funcIFShift,QVariant::fromValue<ushort>(val),false,vfo));
+        queue->add(priorityImmediate,queueItem(funcIFShift,QVariant::fromValue<ushort>(val),false,receiver));
     });
     connect(configFilterWidth, &QSlider::valueChanged, this, [=](const int &val) {
-        queue->add(priorityImmediate,queueItem(funcFilterWidth,QVariant::fromValue<ushort>(val),false,vfo));
+        queue->add(priorityImmediate,queueItem(funcFilterWidth,QVariant::fromValue<ushort>(val),false,receiver));
     });
 
     configGroup->setVisible(false);
@@ -375,7 +395,6 @@ spectrumScope::spectrumScope(QWidget *parent)
     connect(waterfall, SIGNAL(mouseWheel(QWheelEvent*)), this, SLOT(scroll(QWheelEvent*)));
     connect(spectrum, SIGNAL(mouseWheel(QWheelEvent*)), this, SLOT(scroll(QWheelEvent*)));
 
-    connect(freqDisplay, SIGNAL(newFrequency(qint64)), this, SLOT(newFrequency(qint64)));
 
     showHideControls(spectrumMode_t::spectModeCenter);
 }
@@ -540,7 +559,7 @@ bool spectrumScope::updateScope(scopeData data)
             clearPeaks();
         }
         // Inform other threads (cluster) that the frequency range has changed.
-        emit frequencyRange(vfo, data.startFreq, data.endFreq);
+        emit frequencyRange(receiver, data.startFreq, data.endFreq);
     }
 
     lowerFreq = data.startFreq;
@@ -769,7 +788,7 @@ bool spectrumScope::updateScope(scopeData data)
         oorIndicator->setVisible(false);
     }
 
-    emit elapsedTime(vfo, elapsed.elapsed());
+    emit elapsedTime(receiver, elapsed.elapsed());
 
     return true;
 }
@@ -893,14 +912,14 @@ void spectrumScope::updatedScopeMode(int index)
     //spectrumMode_t s = static_cast<spectrumMode_t>(scopeModeCombo->itemData(index).toInt());
     spectrumMode_t s = scopeModeCombo->itemData(index).value<spectrumMode_t>();
 
-    queue->add(priorityImmediate,queueItem((vfo?funcScopeSubMode:funcScopeMainMode),QVariant::fromValue(s),false,vfo));
+    queue->add(priorityImmediate,queueItem((receiver?funcScopeSubMode:funcScopeMainMode),QVariant::fromValue(s),false,receiver));
 
     showHideControls(s);
 }
 
 void spectrumScope::updatedSpan(int index)
 {
-    queue->add(priorityImmediate,queueItem((vfo?funcScopeSubSpan:funcScopeMainSpan),spanCombo->itemData(index),false,vfo));
+    queue->add(priorityImmediate,queueItem((receiver?funcScopeSubSpan:funcScopeMainSpan),spanCombo->itemData(index),false,receiver));
 }
 
 void spectrumScope::updatedMode(int index)
@@ -916,14 +935,14 @@ void spectrumScope::updatedMode(int index)
         mi.data = dataCombo->currentIndex();
         dataCombo->setEnabled(true);
     }
-    queue->add(priorityImmediate,queueItem((vfo?funcUnselectedMode:funcSelectedMode),QVariant::fromValue(mi),false,vfo));
+    queue->add(priorityImmediate,queueItem((receiver?funcSubMode:funcMainMode),QVariant::fromValue(mi),false,receiver));
 
 }
 
 
 void spectrumScope::updatedEdge(int index)
 {
-    queue->add(priorityImmediate,queueItem((vfo?funcScopeSubEdge:funcScopeMainEdge),QVariant::fromValue<uchar>(index+1),false,vfo));
+    queue->add(priorityImmediate,queueItem((receiver?funcScopeSubEdge:funcScopeMainEdge),QVariant::fromValue<uchar>(index+1),false,receiver));
 }
 
 void spectrumScope::toFixedPressed()
@@ -945,8 +964,8 @@ void spectrumScope::toFixedPressed()
             edgeCombo->blockSignals(true);
             edgeCombo->setCurrentIndex(edge-1);
             edgeCombo->blockSignals(false);
-            queue->add(priorityImmediate,queueItem(funcScopeFixedEdgeFreq,QVariant::fromValue(spectrumBounds(lowerFreq, upperFreq, edge)),false,vfo));
-            queue->add(priorityImmediate,queueItem((vfo?funcScopeSubMode:funcScopeMainMode),QVariant::fromValue<uchar>(spectrumMode_t::spectModeFixed),false,vfo));
+            queue->add(priorityImmediate,queueItem(funcScopeFixedEdgeFreq,QVariant::fromValue(spectrumBounds(lowerFreq, upperFreq, edge)),false,receiver));
+            queue->add(priorityImmediate,queueItem((receiver?funcScopeSubMode:funcScopeMainMode),QVariant::fromValue<uchar>(spectrumMode_t::spectModeFixed),false,receiver));
         }
     }
 }
@@ -1014,7 +1033,7 @@ void spectrumScope::doubleClick(QMouseEvent *me)
             freqGo.Hz = roundFrequency(freqGo.Hz, stepSize);
             freqGo.MHzDouble = (float)freqGo.Hz / 1E6;
             setFrequency(freqGo);
-            queue->add(priorityImmediate,queueItem((vfo?funcUnselectedFreq:funcSelectedFreq),QVariant::fromValue<freqt>(freqGo),false,vfo));
+            queue->add(priorityImmediate,queueItem((receiver?funcSubFreq:funcMainFreq),QVariant::fromValue<freqt>(freqGo),false,receiver));
 
         }
     }
@@ -1026,8 +1045,8 @@ void spectrumScope::doubleClick(QMouseEvent *me)
         {
             double pbFreq = (pbtDefault / passbandWidth) * 127.0;
             qint16 newFreq = pbFreq + 128;
-            queue->add(priorityImmediate,queueItem(funcPBTInner,QVariant::fromValue<ushort>(newFreq),false,vfo));
-            queue->add(priorityImmediate,queueItem(funcPBTOuter,QVariant::fromValue<ushort>(newFreq),false,vfo));
+            queue->add(priorityImmediate,queueItem(funcPBTInner,QVariant::fromValue<ushort>(newFreq),false,receiver));
+            queue->add(priorityImmediate,queueItem(funcPBTOuter,QVariant::fromValue<ushort>(newFreq),false,receiver));
         }
     }
 }
@@ -1063,7 +1082,7 @@ void spectrumScope::scopeClick(QMouseEvent* me)
                 freqGo.Hz = (spot.value()->frequency) * 1E6;
                 freqGo.MHzDouble = spot.value()->frequency;
                 setFrequency(freqGo);
-                queue->add(priorityImmediate,queueItem((vfo?funcUnselectedFreq:funcSelectedFreq),QVariant::fromValue<freqt>(freqGo),false,vfo));
+                queue->add(priorityImmediate,queueItem((receiver?funcSubFreq:funcMainFreq),QVariant::fromValue<freqt>(freqGo),false,receiver));
             }
         }
         else if (passbandAction == passbandStatic && rectItem != nullptr)
@@ -1198,7 +1217,7 @@ void spectrumScope::scopeMouseMove(QMouseEvent* me)
             else {
                 pb = passbandIndicator->bottomRight->coords().x() - spectrum->xAxis->pixelToCoord(cursor);
             }
-            queue->add(priorityImmediate,queueItem(funcFilterWidth,QVariant::fromValue<ushort>(pb * 1000000),false,vfo));
+            queue->add(priorityImmediate,queueItem(funcFilterWidth,QVariant::fromValue<ushort>(pb * 1000000),false,receiver));
             //qInfo() << "New passband" << uint(pb * 1000000);
 
             lastFreq = movedFrequency;
@@ -1221,8 +1240,8 @@ void spectrumScope::scopeMouseMove(QMouseEvent* me)
             if (newInFreq >= 0 && newInFreq <= 255 && newOutFreq >= 0 && newOutFreq <= 255) {
                 qDebug() << QString("Moving passband by %1 Hz (Inner %2) (Outer %3) Mode:%4").arg((qint16)(movedFrequency * 1000000))
                                 .arg(newInFreq).arg(newOutFreq).arg(mode.mk);
-                queue->add(priorityImmediate,queueItem(funcPBTInner,QVariant::fromValue<ushort>(newInFreq),false,vfo));
-                queue->add(priorityImmediate,queueItem(funcPBTOuter,QVariant::fromValue<ushort>(newOutFreq),false,vfo));
+                queue->add(priorityImmediate,queueItem(funcPBTInner,QVariant::fromValue<ushort>(newInFreq),false,receiver));
+                queue->add(priorityImmediate,queueItem(funcPBTOuter,QVariant::fromValue<ushort>(newOutFreq),false,receiver));
             }
             lastFreq = movedFrequency;
         }
@@ -1233,7 +1252,7 @@ void spectrumScope::scopeMouseMove(QMouseEvent* me)
             double pbFreq = ((double)(PBTInner + movedFrequency) / passbandWidth) * 127.0;
             qint16 newFreq = pbFreq + 128;
             if (newFreq >= 0 && newFreq <= 255) {
-                queue->add(priorityImmediate,queueItem(funcPBTInner,QVariant::fromValue<ushort>(newFreq),false,vfo));
+                queue->add(priorityImmediate,queueItem(funcPBTInner,QVariant::fromValue<ushort>(newFreq),false,receiver));
             }
             lastFreq = movedFrequency;
         }
@@ -1244,7 +1263,7 @@ void spectrumScope::scopeMouseMove(QMouseEvent* me)
             double pbFreq = ((double)(PBTOuter + movedFrequency) / passbandWidth) * 127.0;
             qint16 newFreq = pbFreq + 128;
             if (newFreq >= 0 && newFreq <= 255) {
-                queue->add(priorityImmediate,queueItem(funcPBTOuter,QVariant::fromValue<ushort>(newFreq),false,vfo));
+                queue->add(priorityImmediate,queueItem(funcPBTOuter,QVariant::fromValue<ushort>(newFreq),false,receiver));
             }
             lastFreq = movedFrequency;
         }
@@ -1260,7 +1279,7 @@ void spectrumScope::scopeMouseMove(QMouseEvent* me)
             freqGo.Hz = roundFrequency(freqGo.Hz, stepSize);
             freqGo.MHzDouble = (float)freqGo.Hz / 1E6;
             setFrequency(freqGo);
-            queue->add(priorityImmediate,queueItem((vfo?funcUnselectedFreq:funcSelectedFreq),QVariant::fromValue<freqt>(freqGo),false,vfo));
+            queue->add(priorityImmediate,queueItem((receiver?funcSubFreq:funcMainFreq),QVariant::fromValue<freqt>(freqGo),false,receiver));
         }
     }
     else {
@@ -1334,22 +1353,25 @@ void spectrumScope::scroll(QWheelEvent *we)
     freq = f; // Do we need to do this?
 
     setFrequency(f);
-    queue->add(priorityImmediate,queueItem((vfo?funcUnselectedFreq:funcSelectedFreq),QVariant::fromValue<freqt>(f),false,vfo));
+    queue->add(priorityImmediate,queueItem((receiver?funcSubFreq:funcMainFreq),QVariant::fromValue<freqt>(f),false,receiver));
     //qInfo() << "Moving to freq:" << f.Hz << "step" << stepsHz;
     scrollWheelOffsetAccumulated = 0;
 }
 
 
 
-void spectrumScope::receiveMode(modeInfo m)
+void spectrumScope::receiveMode(modeInfo m, uchar vfo)
 {
     // Update mode information if mode/filter/data has changed.
     // Not all rigs send data so this "might" need to be updated independantly?
+    if (vfo > 0)
+        return;
+
     if (mode.reg != m.reg || m.filter != mode.filter || m.data != mode.data)
     {
 
         qDebug(logSystem()) << __func__ << QString("Received new mode for %0: %1 (%2) filter:%3 data:%4")
-                                              .arg((vfo?"Sub":"Main")).arg(QString::number(m.mk,16)).arg(m.name).arg(m.filter).arg(m.data) ;
+                                              .arg((receiver?"Sub":"Main")).arg(QString::number(m.mk,16)).arg(m.name).arg(m.filter).arg(m.data) ;
 
         if (mode.mk != m.mk) {
             for (int i=0;i<modeCombo->count();i++)
@@ -1400,13 +1422,13 @@ void spectrumScope::receiveMode(modeInfo m)
 
             // If new mode doesn't allow bandwidth control, disable filterwidth and pbt.
             if (m.bwMin > 0 && m.bwMax > 0) {
-                queue->addUnique(priorityHigh,funcPBTInner,true,vfo);
-                queue->addUnique(priorityHigh,funcPBTOuter,true,vfo);
-                queue->addUnique(priorityHigh,funcFilterWidth,true,vfo);
+                queue->addUnique(priorityHigh,funcPBTInner,true,receiver);
+                queue->addUnique(priorityHigh,funcPBTOuter,true,receiver);
+                queue->addUnique(priorityHigh,funcFilterWidth,true,receiver);
             } else{
-                queue->del(funcPBTInner,vfo);
-                queue->del(funcPBTOuter,vfo);
-                queue->del(funcFilterWidth,vfo);
+                queue->del(funcPBTInner,receiver);
+                queue->del(funcPBTOuter,receiver);
+                queue->del(funcFilterWidth,receiver);
             }
 
 #if defined __GNUC__
@@ -1419,9 +1441,9 @@ void spectrumScope::receiveMode(modeInfo m)
             case modeRTTY:
             case modeRTTY_R:
                 passbandCenterFrequency = 0.00008925;
-                queue->del(funcCwPitch,vfo);
-                queue->del(funcDashRatio,vfo);
-                queue->del(funcKeySpeed,vfo);
+                queue->del(funcCwPitch,receiver);
+                queue->del(funcDashRatio,receiver);
+                queue->del(funcKeySpeed,receiver);
                 break;
             case modeLSB:
             case modeUSB:
@@ -1429,15 +1451,15 @@ void spectrumScope::receiveMode(modeInfo m)
             case modePSK_R:
                 passbandCenterFrequency = 0.0015;
             case modeAM:
-                queue->del(funcCwPitch,vfo);
-                queue->del(funcDashRatio,vfo);
-                queue->del(funcKeySpeed,vfo);
+                queue->del(funcCwPitch,receiver);
+                queue->del(funcDashRatio,receiver);
+                queue->del(funcKeySpeed,receiver);
                 break;
             case modeCW:
             case modeCW_R:
-                queue->addUnique(priorityLow,funcCwPitch,true,vfo);
-                queue->addUnique(priorityLow,funcDashRatio,true,vfo);
-                queue->addUnique(priorityLow,funcKeySpeed,true,vfo);
+                queue->addUnique(priorityLow,funcCwPitch,true,receiver);
+                queue->addUnique(priorityLow,funcDashRatio,true,receiver);
+                queue->addUnique(priorityLow,funcKeySpeed,true,receiver);
                 break;
             default:
                 // FM and digital modes are fixed width, not sure about any other modes?
@@ -1448,9 +1470,9 @@ void spectrumScope::receiveMode(modeInfo m)
                 else
                     passbandWidth = 0.007;
                 break;
-                queue->del(funcCwPitch,vfo);
-                queue->del(funcDashRatio,vfo);
-                queue->del(funcKeySpeed,vfo);
+                queue->del(funcCwPitch,receiver);
+                queue->del(funcDashRatio,receiver);
+                queue->del(funcKeySpeed,receiver);
                 break;
             }
 #if defined __GNUC__
@@ -1494,7 +1516,7 @@ void spectrumScope::receiveCwPitch(uchar pitch)
         if (p != this->cwPitch)
         {
             passbandCenterFrequency = p / 2000000.0;
-            qDebug(logSystem()) << QString("%0 Received new CW Pitch %1 Hz was %2 (center freq %3 MHz)").arg((vfo?"Sub":"Main")).arg(p).arg(cwPitch).arg(passbandCenterFrequency);
+            qDebug(logSystem()) << QString("%0 Received new CW Pitch %1 Hz was %2 (center freq %3 MHz)").arg((receiver?"Sub":"Main")).arg(p).arg(cwPitch).arg(passbandCenterFrequency);
             this->cwPitch = p;
         }
     }
@@ -1506,8 +1528,8 @@ void spectrumScope::receivePassband(quint16 pass)
     if (passbandWidth != pb) {
         passbandWidth = pb;
         //trxadj->updatePassband(pass);
-        qDebug(logSystem()) << QString("%0 Received new IF Filter/Passband %1 Hz").arg(vfo?"Sub":"Main").arg(pass);
-        emit showStatusBarText(QString("%0 IF filter width %1 Hz (%2 MHz)").arg(vfo?"Sub":"Main").arg(pass).arg(passbandWidth));
+        qDebug(logSystem()) << QString("%0 Received new IF Filter/Passband %1 Hz").arg(receiver?"Sub":"Main").arg(pass);
+        emit showStatusBarText(QString("%0 IF filter width %1 Hz (%2 MHz)").arg(receiver?"Sub":"Main").arg(pass).arg(passbandWidth));
     }
 }
 
@@ -1523,7 +1545,7 @@ void spectrumScope::selected(bool en)
 
 void spectrumScope::holdPressed(bool en)
 {
-    queue->add(priorityImmediate,queueItem(vfo?funcScopeSubHold:funcScopeMainHold,QVariant::fromValue(en),false,vfo));
+    queue->add(priorityImmediate,queueItem(receiver?funcScopeSubHold:funcScopeMainHold,QVariant::fromValue(en),false,receiver));
 }
 
 void spectrumScope::setHold(bool h)
@@ -1540,9 +1562,9 @@ void spectrumScope::setSpeed(uchar s)
 }
 
 
-void spectrumScope::receiveSpots(uchar vfo, QList<spotData> spots)
+void spectrumScope::receiveSpots(uchar receiver, QList<spotData> spots)
 {
-    if (vfo != this->vfo) {
+    if (receiver != this->receiver) {
         return;
     }
     //QElapsedTimer timer;
@@ -1701,33 +1723,49 @@ void spectrumScope::setPBTOuter (uchar val) {
     }
 }
 
-void spectrumScope::setFrequency(freqt f)
+void spectrumScope::setFrequency(freqt f, uchar vfo)
 {
-    freqDisplay->blockSignals(true);
-    freqDisplay->setFrequency(f.Hz);
-    freqDisplay->blockSignals(false);
-    freq = f;
+    //qInfo() << "Setting Frequency vfo=" << vfo << "Freq:" << f.Hz;
+
+    if (vfo < numVFO)
+    {
+        freqDisplay[vfo]->blockSignals(true);
+        freqDisplay[vfo]->setFrequency(f.Hz);
+        freqDisplay[vfo]->blockSignals(false);
+    }
+    if (vfo==0)
+        freq = f;
+
 }
 
 void spectrumScope::displaySettings(int numDigits, qint64 minf, qint64 maxf, int minStep,FctlUnit unit,std::vector<bandType>* bands)
 {
-    freqDisplay->setup(numDigits, minf, maxf, minStep, unit, bands);
+    for (uchar i=0;i<numVFO;i++)
+        freqDisplay[i]->setup(numDigits, minf, maxf, minStep, unit, bands);
 }
 
 void spectrumScope::setUnit(FctlUnit unit)
 {
-    freqDisplay->setUnit(unit);
+    for (uchar i=0;i<numVFO;i++)
+        freqDisplay[i]->setUnit(unit);
 }
 
 
-void spectrumScope::newFrequency(qint64 freq)
+void spectrumScope::newFrequency(qint64 freq,uchar vfo)
 {
     freqt f;
     f.Hz = freq;
     f.MHzDouble = f.Hz / (double)1E6;
     if (f.Hz > 0)
     {
-        queue->add(priorityImmediate,queueItem((vfo?funcUnselectedFreq:funcSelectedFreq),QVariant::fromValue<freqt>(f),false,vfo));
+        if (vfo > 0)
+        {
+            queue->add(priorityImmediate,queueItem((funcUnselectedFreq),QVariant::fromValue<freqt>(f),false,receiver));
+        }
+        else
+        {
+            queue->add(priorityImmediate,queueItem((receiver?funcSubFreq:funcMainFreq),QVariant::fromValue<freqt>(f),false,receiver));
+        }
     }
 }
 
@@ -1747,14 +1785,14 @@ void spectrumScope::detachScope(bool state)
     {
         windowLabel = new QLabel();
         detachButton->setText("Attach");
-        qInfo(logGui()) << "Detaching scope" << (vfo?"Sub":"Main");
+        qInfo(logGui()) << "Detaching scope" << (receiver?"Sub":"Main");
         this->parentWidget()->layout()->replaceWidget(this,windowLabel);
         this->setParent(NULL);
         this-> setWindowFlags(Qt::Window | Qt::WindowMinimizeButtonHint | Qt::WindowMaximizeButtonHint);
         this->move(screen()->geometry().center() - frameGeometry().center());
     } else {
         detachButton->setText("Detach");
-        qInfo(logGui()) << "Attaching scope" << (vfo?"Sub":"Main");
+        qInfo(logGui()) << "Attaching scope" << (receiver?"Sub":"Main");
         windowLabel->parentWidget()->layout()->replaceWidget(windowLabel,this);
         windowLabel->setParent(NULL);
         delete windowLabel;

spectrumscope.h

@@ -30,7 +30,7 @@ class spectrumScope : public QGroupBox
 {
     Q_OBJECT
 public:
-    explicit spectrumScope(QWidget *parent = nullptr);
+    explicit spectrumScope(uchar receiver = 0, uchar vfo = 1, QWidget *parent = nullptr);
 
     bool prepareWf(uint wfLength);
     void prepareScope(uint ampMap, uint spectWidth);
@@ -50,8 +50,8 @@ public:
     void setPassbandWidth(double hz) { passbandWidth = hz;}
     double getPassbandWidth() { configFilterWidth->setValue(passbandWidth*1E6); return passbandWidth;}
 
-    void setIdentity(QString name, uchar v) {this->setTitle(name), vfo = v;}
-    bool getVfo() { return vfo;}
+    void setIdentity(QString name) {this->setTitle(name);}
+    bool getVfo() { return receiver;}
 
     void setTuningFloorZeros(bool tf) {this->tuningFloorZeros = tf;}
     void setClickDragTuning(bool cg) { this->clickDragTuning = cg;}
@@ -73,9 +73,11 @@ public:
     void setStepSize (quint16 hz) { stepSize = hz;}
 
     freqt getFrequency () { return freq;}
-    void setFrequency (freqt f);
+    void setFrequency (freqt f,uchar vfo=0);
 
-    void receiveMode (modeInfo m);
+    uchar getNumVFO () { return numVFO;}
+
+    void receiveMode (modeInfo m, uchar vfo=0);
     modeInfo currentMode() {return mode;}
     void clearSpans() { spanCombo->clear();}
     void clearMode() { modeCombo->clear();}
@@ -100,15 +102,15 @@ public:
 public slots: // Can be called directly or updated via signal/slot
     void selectScopeMode(spectrumMode_t m);
     void selectSpan(centerSpanData s);
-    void receiveSpots(uchar vfo, QList<spotData> spots);
+    void receiveSpots(uchar receiver, QList<spotData> spots);
 
 signals:    
-    void frequencyRange(uchar vfo, double start, double end);
+    void frequencyRange(uchar receiver, double start, double end);
     void updateScopeMode(spectrumMode_t index);
     void updateSpan(centerSpanData s);
     void showStatusBarText(QString text);
-    void updateSettings(uchar vfo, int value, quint16 len, int floor, int ceiling);
-    void elapsedTime(uchar vfo, qint64 ns);
+    void updateSettings(uchar receiver, int value, quint16 len, int floor, int ceiling);
+    void elapsedTime(uchar receiver, qint64 ns);
     void dataChanged(modeInfo m);
 
 private slots:
@@ -131,7 +133,7 @@ private slots:
     void scroll(QWheelEvent *);
 
     void clearPeaks();
-    void newFrequency(qint64 freq);
+    void newFrequency(qint64 freq,uchar i=0);
 
 private:
     void clearPlasma();
@@ -147,7 +149,7 @@ private:
     QLabel* windowLabel = Q_NULLPTR;
     QCustomPlot* spectrum = Q_NULLPTR;
     QCustomPlot* waterfall = Q_NULLPTR;
-    freqCtrl* freqDisplay;
+    freqCtrl* freqDisplay[2];
     QSpacerItem* displaySpacer;
     QGroupBox* group;
     QSplitter* splitter;
@@ -263,7 +265,7 @@ private:
     QVector <QByteArray> wfimage;
 
     cachingQueue* queue;
-    uchar vfo=0;
+    uchar receiver=0;
     double startFrequency;
     QMap<QString, spotData*> clusterSpots;
 
@@ -271,6 +273,7 @@ private:
     bool tuningFloorZeros=false;
     bool clickDragTuning=false;
     bool isActive;
+    uchar numVFO=1;
 };
 
 #endif // SPECTRUMSCOPE_H

tciserver.cpp

@@ -22,7 +22,7 @@ static const tciCommandStruct tci_commands[] =
     { "dds",                funcNone, typeUChar,typeFreq},
     { "if",                 funcNone,       typeUChar,typeUChar,typeFreq},
     { "vfo",                funcNone,       typeUChar,typeUChar,typeFreq},
-    { "modulation",         funcSelectedMode,  typeUChar,typeShort},
+    { "modulation",         funcMainMode,  typeUChar,typeShort},
     { "trx",                funcTransceiverStatus,       typeUChar},
     { "tune",               funcTunerStatus,       typeUChar},
     { "drive",              funcNone,       typeUChar},
@@ -182,8 +182,8 @@ void tciServer::onNewConnection()
     pSocket->sendTextMessage(QString("iq_samplerate:48000;\n"));
     pSocket->sendTextMessage(QString("audio_samplerate:48000;\n"));
     pSocket->sendTextMessage(QString("mute:false;\n"));
-    pSocket->sendTextMessage(QString("vfo:0,0,%0;").arg(queue->getCache(funcSelectedFreq,false).value.value<freqt>().Hz));
-    pSocket->sendTextMessage(QString("modulation:0,%0;").arg(queue->getCache(funcSelectedMode,false).value.value<modeInfo>().name.toLower()));
+    pSocket->sendTextMessage(QString("vfo:0,0,%0;").arg(queue->getCache(funcMainFreq,false).value.value<freqt>().Hz));
+    pSocket->sendTextMessage(QString("modulation:0,%0;").arg(queue->getCache(funcMainMode,false).value.value<modeInfo>().name.toLower()));
     pSocket->sendTextMessage(QString("start;\n"));
     pSocket->sendTextMessage(QString("ready;\n"));
 }
@@ -222,7 +222,7 @@ void tciServer::processIncomingTextMessage(QString message)
     if (cmd.toLower() == "modulation")
     {
         reply = QString("%0:%1,%2;").arg(cmd).arg(sub)
-                    .arg(queue->getCache(sub?funcUnselectedFreq:funcSelectedMode,sub).value.value<modeInfo>().name);
+                    .arg(queue->getCache(sub?funcSubFreq:funcMainMode,sub).value.value<modeInfo>().name);
     } else if (cmd == "rx_enable" || cmd == "tx_enable") {
         reply = QString("%0:%1,%2;").arg(cmd).arg(sub).arg("true");
     }
@@ -254,31 +254,31 @@ void tciServer::processIncomingTextMessage(QString message)
     {
         if (arg.size() == 2) {
             reply = QString("%0:%1,%2,%3;").arg(cmd,arg[0],arg[1])
-                        .arg(queue->getCache(sub?funcUnselectedFreq:funcSelectedFreq,sub).value.value<freqt>().Hz);
+                        .arg(queue->getCache(sub?funcSubFreq:funcMainFreq,sub).value.value<freqt>().Hz);
         }
         else if (arg.size() == 3) {
             qInfo() << "Freq" << arg[2];
             freqt f;
             f.Hz = arg[2].toUInt();
             f.MHzDouble = f.Hz / (double)1E6;
-            queue->add(priorityImmediate,queueItem(sub?funcUnselectedFreq:funcSelectedFreq,QVariant::fromValue(f),false,sub));
+            queue->add(priorityImmediate,queueItem(sub?funcSubFreq:funcMainFreq,QVariant::fromValue(f),false,sub));
         }
     }
     else if (cmd == "modulation")
     {
         if (arg.size() == 1) {
             reply = QString("modulation:%0,%1;").arg(
-                        QString::number(sub),queue->getCache(sub?funcUnselectedMode:funcSelectedMode,sub).value.value<modeInfo>().name.toLower());
+                        QString::number(sub),queue->getCache(sub?funcSubMode:funcMainMode,sub).value.value<modeInfo>().name.toLower());
         }
         else if (arg.size() == 2) {
             qInfo() << "Mode (TODO)" << arg[1];
             reply = QString("modulation:%0,%1;").arg(
-                        QString::number(sub),queue->getCache(sub?funcUnselectedMode:funcSelectedMode,sub).value.value<modeInfo>().name.toLower());
+                        QString::number(sub),queue->getCache(sub?funcSubMode:funcMainMode,sub).value.value<modeInfo>().name.toLower());
             /*
             freqt f;
             f.Hz = arg[2].toUInt();
             f.MHzDouble = f.Hz / (double)1E6;
-            queue->add(priorityImmediate,queueItem(sub?funcUnselectedFreq:funcSelectedFreq,QVariant::fromValue(f),false,sub));
+            queue->add(priorityImmediate,queueItem(sub?funcSubFreq:funcMainFreq,QVariant::fromValue(f),false,sub));
             */
         }
     }
@@ -370,17 +370,17 @@ void tciServer::receiveCache(cacheItem item)
             switch (item.command)
             {
             case funcFreqTR:
-            case funcSelectedFreq:
-            case funcUnselectedFreq:
-                reply = QString("vfo:0,%0,%1;").arg(QString::number(item.vfo),item.value.value<freqt>().Hz);
+            case funcMainFreq:
+            case funcSubFreq:
+                reply = QString("vfo:0,%0,%1;").arg(QString::number(item.receiver),item.value.value<freqt>().Hz);
                 break;
             case funcModeTR:
-            case funcSelectedMode:
-            case funcUnselectedMode:
-                reply = QString("modulation:%0,%1;").arg(QString::number(item.vfo),item.value.value<modeInfo>().name.toLower());
+            case funcMainMode:
+            case funcSubMode:
+                reply = QString("modulation:%0,%1;").arg(QString::number(item.receiver),item.value.value<modeInfo>().name.toLower());
                 break;
             case funcTransceiverStatus:
-                reply = QString("trx:%0,%1;").arg(QString::number(item.vfo),item.value.value<bool>()?"true":"false");
+                reply = QString("trx:%0,%1;").arg(QString::number(item.receiver),item.value.value<bool>()?"true":"false");
                 break;
             default:
                 break;

usbcontroller.cpp

@@ -706,7 +706,7 @@ void usbController::runTimer()
                         if ((!but->isOn) && ((tempButtons >> i & 1) && !(dev->buttons >> i & 1)))
                         {
                             qDebug(logUsbControl()) << QString("On Button event for button %0: %1").arg(but->num).arg(but->onCommand->text);
-                            if (but->onCommand->command == cmdPageUp)
+                            if (but->onCommand->command == funcPageUp)
                                 emit changePage(dev, dev->currentPage+1);
                             else if (but->onCommand->command == funcPageDown)
                                 emit changePage(dev, dev->currentPage-1);
@@ -796,7 +796,7 @@ void usbController::runTimer()
                     if (kb != knobList->end()) {
                         // sendCommand mustn't be deleted so we ensure it stays in-scope by declaring it private (we will only ever send one command).
                         sendCommand = *kb->command;
-                        if (sendCommand.command != funcSelectedFreq && sendCommand.command != funcUnselectedFreq) {
+                        if (sendCommand.command != funcMainFreq && sendCommand.command != funcSubFreq) {
                             int tempVal = dev->knobValues[i].value * dev->sensitivity;
                             tempVal = qMin(qMax(tempVal,0),255);
                             sendCommand.suffix = quint8(tempVal);
@@ -811,7 +811,7 @@ void usbController::runTimer()
                         
                         emit button(&sendCommand);
 
-                        if (sendCommand.command == funcSelectedFreq || sendCommand.command == funcUnselectedFreq) {
+                        if (sendCommand.command == funcMainFreq || sendCommand.command == funcSubFreq) {
                             dev->knobValues[i].value = 0;
                         }
                         dev->knobValues[i].previous=dev->knobValues[i].value;
@@ -1663,10 +1663,10 @@ void usbController::loadCommands()
     commands.append(COMMAND(num++, "None", commandAny, funcNone, (quint8)0x0));
     commands.append(COMMAND(num++, "PTT On", commandButton, funcTransceiverStatus,  (quint8)0x1));
     commands.append(COMMAND(num++, "PTT Off", commandButton, funcTransceiverStatus, (quint8)0x0));
-    commands.append(COMMAND(num++, "VFOA", commandKnob, funcSelectedFreq, (quint8)0x0));
-    commands.append(COMMAND(num++, "VFOB", commandKnob, funcUnselectedFreq, (quint8)0x1));
-    commands.append(COMMAND(num++, "Freq Down", commandButton, funcSelectedFreq,(int)-1));
-    commands.append(COMMAND(num++, "Freq Up", commandButton, funcSelectedFreq, (int)1));
+    commands.append(COMMAND(num++, "VFOA", commandKnob, funcMainFreq, (quint8)0x0));
+    commands.append(COMMAND(num++, "VFOB", commandKnob, funcSubFreq, (quint8)0x1));
+    commands.append(COMMAND(num++, "Freq Down", commandButton, funcMainFreq,(int)-1));
+    commands.append(COMMAND(num++, "Freq Up", commandButton, funcMainFreq, (int)1));
     commands.append(COMMAND(num++, "PTT Off", commandButton, funcTransceiverStatus, (quint8)0x0));
     commands.append(COMMAND(num++, "PTT Toggle", commandButton, funcTransceiverStatus,  (quint8)0x0));
     commands.append(COMMAND(num++, "Span/Step", commandKnob, funcSeparator, (quint8)0x0));
@@ -1679,38 +1679,38 @@ void usbController::loadCommands()
     commands.append(COMMAND(num++, "Sub Span+", commandButton, funcScopeSubSpan, 100));
     commands.append(COMMAND(num++, "Sub Span-", commandButton, funcScopeSubSpan, -100));
     commands.append(COMMAND(num++, "Modes", commandButton, funcSeparator, (quint8)0x0));
-    commands.append(COMMAND(num++, "Main Mode+", commandButton, funcSelectedMode, 100));
-    commands.append(COMMAND(num++, "Main Mode-", commandButton, funcSelectedMode, -100));
-    commands.append(COMMAND(num++, "Sub Mode+", commandButton, funcUnselectedMode, 100));
-    commands.append(COMMAND(num++, "Sub Mode-", commandButton, funcUnselectedMode, -100));
-    commands.append(COMMAND(num++, "Main LSB", commandButton, funcSelectedMode, modeLSB));
-    commands.append(COMMAND(num++, "Main USB", commandButton, funcSelectedMode, modeUSB));
-    commands.append(COMMAND(num++, "Main LSBD", commandButton, funcSelectedMode, modeLSB_D));
-    commands.append(COMMAND(num++, "Main USBD", commandButton, funcSelectedMode, modeUSB_D));
-    commands.append(COMMAND(num++, "Main CW", commandButton, funcSelectedMode, modeCW));
-    commands.append(COMMAND(num++, "Main CWR", commandButton, funcSelectedMode, modeCW_R));
-    commands.append(COMMAND(num++, "Main FM", commandButton, funcSelectedMode, modeFM));
-    commands.append(COMMAND(num++, "Main AM", commandButton, funcSelectedMode, modeAM));
-    commands.append(COMMAND(num++, "Main RTTY", commandButton, funcSelectedMode, modeRTTY));
-    commands.append(COMMAND(num++, "Main RTTYR", commandButton, funcSelectedMode, modeRTTY_R));
-    commands.append(COMMAND(num++, "Main PSK", commandButton, funcSelectedMode, modePSK));
-    commands.append(COMMAND(num++, "Main PSKR", commandButton, funcSelectedMode, modePSK_R));
-    commands.append(COMMAND(num++, "Main DV", commandButton, funcSelectedMode, modeDV));
-    commands.append(COMMAND(num++, "Main DD", commandButton, funcSelectedMode, modeDD));
-    commands.append(COMMAND(num++, "Sub LSB", commandButton, funcUnselectedMode, modeLSB));
-    commands.append(COMMAND(num++, "Sub USB", commandButton, funcUnselectedMode, modeUSB));
-    commands.append(COMMAND(num++, "Sub LSBD", commandButton, funcUnselectedMode, modeLSB_D));
-    commands.append(COMMAND(num++, "Sub USBD", commandButton, funcUnselectedMode, modeUSB_D));
-    commands.append(COMMAND(num++, "Sub CW", commandButton, funcUnselectedMode, modeCW));
-    commands.append(COMMAND(num++, "Sub CWR", commandButton, funcUnselectedMode, modeCW_R));
-    commands.append(COMMAND(num++, "Sub FM", commandButton, funcUnselectedMode, modeFM));
-    commands.append(COMMAND(num++, "Sub AM", commandButton, funcUnselectedMode, modeAM));
-    commands.append(COMMAND(num++, "Sub RTTY", commandButton, funcUnselectedMode, modeRTTY));
-    commands.append(COMMAND(num++, "Sub RTTYR", commandButton, funcUnselectedMode, modeRTTY_R));
-    commands.append(COMMAND(num++, "Sub PSK", commandButton, funcUnselectedMode, modePSK));
-    commands.append(COMMAND(num++, "Sub PSKR", commandButton, funcUnselectedMode, modePSK_R));
-    commands.append(COMMAND(num++, "Sub DV", commandButton, funcUnselectedMode, modeDV));
-    commands.append(COMMAND(num++, "Sub DD", commandButton, funcUnselectedMode, modeDD));
+    commands.append(COMMAND(num++, "Main Mode+", commandButton, funcMainMode, 100));
+    commands.append(COMMAND(num++, "Main Mode-", commandButton, funcMainMode, -100));
+    commands.append(COMMAND(num++, "Sub Mode+", commandButton, funcMainMode, 100));
+    commands.append(COMMAND(num++, "Sub Mode-", commandButton, funcMainMode, -100));
+    commands.append(COMMAND(num++, "Main LSB", commandButton, funcMainMode, modeLSB));
+    commands.append(COMMAND(num++, "Main USB", commandButton, funcMainMode, modeUSB));
+    commands.append(COMMAND(num++, "Main LSBD", commandButton, funcMainMode, modeLSB_D));
+    commands.append(COMMAND(num++, "Main USBD", commandButton, funcMainMode, modeUSB_D));
+    commands.append(COMMAND(num++, "Main CW", commandButton, funcMainMode, modeCW));
+    commands.append(COMMAND(num++, "Main CWR", commandButton, funcMainMode, modeCW_R));
+    commands.append(COMMAND(num++, "Main FM", commandButton, funcMainMode, modeFM));
+    commands.append(COMMAND(num++, "Main AM", commandButton, funcMainMode, modeAM));
+    commands.append(COMMAND(num++, "Main RTTY", commandButton, funcMainMode, modeRTTY));
+    commands.append(COMMAND(num++, "Main RTTYR", commandButton, funcMainMode, modeRTTY_R));
+    commands.append(COMMAND(num++, "Main PSK", commandButton, funcMainMode, modePSK));
+    commands.append(COMMAND(num++, "Main PSKR", commandButton, funcMainMode, modePSK_R));
+    commands.append(COMMAND(num++, "Main DV", commandButton, funcMainMode, modeDV));
+    commands.append(COMMAND(num++, "Main DD", commandButton, funcMainMode, modeDD));
+    commands.append(COMMAND(num++, "Sub LSB", commandButton, funcMainMode, modeLSB));
+    commands.append(COMMAND(num++, "Sub USB", commandButton, funcMainMode, modeUSB));
+    commands.append(COMMAND(num++, "Sub LSBD", commandButton, funcMainMode, modeLSB_D));
+    commands.append(COMMAND(num++, "Sub USBD", commandButton, funcMainMode, modeUSB_D));
+    commands.append(COMMAND(num++, "Sub CW", commandButton, funcMainMode, modeCW));
+    commands.append(COMMAND(num++, "Sub CWR", commandButton, funcMainMode, modeCW_R));
+    commands.append(COMMAND(num++, "Sub FM", commandButton, funcMainMode, modeFM));
+    commands.append(COMMAND(num++, "Sub AM", commandButton, funcMainMode, modeAM));
+    commands.append(COMMAND(num++, "Sub RTTY", commandButton, funcMainMode, modeRTTY));
+    commands.append(COMMAND(num++, "Sub RTTYR", commandButton, funcMainMode, modeRTTY_R));
+    commands.append(COMMAND(num++, "Sub PSK", commandButton, funcMainMode, modePSK));
+    commands.append(COMMAND(num++, "Sub PSKR", commandButton, funcMainMode, modePSK_R));
+    commands.append(COMMAND(num++, "Sub DV", commandButton, funcMainMode, modeDV));
+    commands.append(COMMAND(num++, "Sub DD", commandButton, funcMainMode, modeDD));
     commands.append(COMMAND(num++, "Bands", commandButton, funcSeparator, (quint8)0x0));
     commands.append(COMMAND(num++, "Band+", commandButton, funcBandStackReg, 100));
     commands.append(COMMAND(num++, "Band-", commandButton, funcBandStackReg, -100));

wfmain.h

@@ -123,7 +123,7 @@ signals:
     // Frequency, mode, band:
     void getFrequency();
     void getFrequency(unsigned char);
-    void setFrequency(unsigned char vfo, freqt freq);
+    void setFrequency(unsigned char receiver, freqt freq);
     void getMode();
     void setMode(unsigned char modeIndex, unsigned char modeFilter);
     void setMode(modeInfo);
@@ -331,7 +331,7 @@ private slots:
 
     void handleExtConnectBtn();
 
-    void receiveScopeSettings(uchar vfo, int theme, quint16 len, int floor, int ceiling);
+    void receiveScopeSettings(uchar receiver, int theme, quint16 len, int floor, int ceiling);
     void receiveValue(cacheItem val);
     void setAudioDevicesUI();
     void shortcutF1();
@@ -395,7 +395,7 @@ private slots:
     void receiveIFShift(unsigned char level);
 
     // Meters:
-    void receiveMeter(meter_t meter, unsigned char level, unsigned char vfo=0);
+    void receiveMeter(meter_t meter, unsigned char level, unsigned char receiver=0);
 //    void receiveSMeter(unsigned char level);
 //    void receivePowerMeter(unsigned char level);
 //    void receiveALCMeter(unsigned char level);
@@ -403,9 +403,9 @@ private slots:
 
 
     void receiveATUStatus(unsigned char atustatus);
-    void receivePreamp(unsigned char pre, uchar vfo);
-    void receiveAttenuator(unsigned char att, uchar vfo);
-    void receiveAntennaSel(unsigned char ant, bool rx,uchar vfo);
+    void receivePreamp(unsigned char pre, uchar receiver);
+    void receiveAttenuator(unsigned char att, uchar receiver);
+    void receiveAntennaSel(unsigned char ant, bool rx,uchar receiver);
 
     void receivePortError(errorType err);
     void receiveStatusUpdate(networkStatus status);
@@ -502,7 +502,7 @@ private slots:
 
 private:
     Ui::wfmain *ui; // Main UI
-    QVector<spectrumScope*>vfos;   // Spectrum Scope/VFO item.
+    QVector<spectrumScope*>receivers;   // Spectrum Scope items.
     void closeEvent(QCloseEvent *event);
     QString logFilename;
     bool debugMode;
@@ -710,6 +710,9 @@ private:
 
     void updateUsbButtons();
 
+    void displayReceiver(uchar rx, bool active, bool swtch);
+
+
     int oldFreqDialVal;
 
     QHash<unsigned char,QString> rigList;

wfviewtypes.h

@@ -140,7 +140,7 @@ struct antennaInfo {
 struct scopeData {
     bool valid=false;
     QByteArray data;
-    uchar vfo;
+    uchar receiver;
     spectrumMode_t mode;
     bool oor;
     double startFreq;
@@ -178,6 +178,7 @@ struct timekind {
     bool isMinus;
 };
 
+/*
 enum cmds {
 cmdNone, cmdGetRigID, cmdGetRigCIV, cmdGetFreq, cmdGetFreqB, cmdSetFreq, cmdGetMode, cmdSetMode,
 cmdGetDataMode, cmdSetModeFilter, cmdSetDataModeOn, cmdSetDataModeOff, cmdGetRitEnabled, cmdGetRitValue,
@@ -211,9 +212,11 @@ cmdSetSpanUp, cmdSetSpanDown, cmdIFFilterUp, cmdIFFilterDown, cmdPageDown, cmdPa
 cmdLCDWaterfall, cmdLCDSpectrum, cmdLCDNothing, cmdSeparator
 };
 
+*/
+
 
 // funcs and funcString MUST match exactly (and NUMFUNCS must be updated)
-#define NUMFUNCS 244
+#define NUMFUNCS 248
 
 enum funcs { funcNone,
 funcFreqTR,             funcModeTR,             funcBandEdgeFreq,           funcFreqGet,        	funcModeGet,        	funcFreqSet,			// \x00
@@ -242,8 +245,9 @@ funcRecorderPTTAuto,    funcRecorderPreRec,		funcRXAntConnector,         funcAnt
 funcVOXDelay,           funcVOXVoiceDelay,		funcAPFType,                funcAPFTypeLevel,       funcPSKTone,            funcRTTYMarkTone,
 funcDataModeWithFilter, funcAFMute,				funcToneFreq,               funcTSQLFreq,           funcDTCSCode,           funcCSQLCode,
 funcTransceiverStatus,  funcXFCStatus,			funcReadTXFreq,             funcCIVOutput,          funcReadTXFreqs,        funcReadUserTXFreqs,
-funcUserTXBandEdgeFreq, funcRITFreq,			funcRitStatus,              funcRitTXStatus,        funcSelectedFreq,       funcSelectedMode,
-funcUnselectedFreq,     funcUnselectedMode,     funcScopeMainWaveData,      funcScopeSubWaveData,   funcScopeOnOff,         funcScopeDataOutput,
+funcUserTXBandEdgeFreq, funcRITFreq,			funcRitStatus,              funcRitTXStatus,        funcSelectedFreq,       funcUnselectedFreq,
+funcSelectedMode,       funcUnselectedMode,     funcMainFreq,               funcSubFreq,            funcMainMode,           funcSubMode,
+funcScopeMainWaveData,  funcScopeSubWaveData,   funcScopeOnOff,             funcScopeDataOutput,
 funcScopeMainSub,       funcScopeSingleDual,	funcScopeMainMode,          funcScopeSubMode,       funcScopeMainSpan,      funcScopeSubSpan,
 funcScopeMainEdge,      funcScopeSubEdge,       funcScopeMainHold,          funcScopeSubHold,       funcScopeMainRef,       funcScopeSubRef,
 funcScopeMainSpeed,     funcScopeSubSpeed,      funcScopeMainVBW,           funcScopeSubVBW,        funcScopeMainRBW,       funcScopeSubRBW,
@@ -289,8 +293,9 @@ static QString funcString[] { "None",
 "VOX Delay",            "VOX Voice Delay",      "APF Type",                 "APF Type Level",       "PSK Tone",             "RTTY Mark Tone",
 "Data Mode Filter",     "AF Mute Status",       "Tone Frequency",           "TSQL Frequency",       "DTCS Code/Polarity",   "CSQL Code",
 "Transceiver Status",   "XFC Status",           "Read TX Freq",             "CI-V Output",          "Read TX Freqs",        "Read User TX Freqs",
-"User TX Band Edge Freq","RIT Frequency",       "RIT Status",               "RIT TX Status",        "Selected Freq",        "Selected Mode",
-"Unselected Freq",      "Unselected Mode",      "Scope Main Wave Data",     "Scope Sub Wave Data",  "Scope On/Off",         "Scope Data Output",
+"User TX Band Edge Freq","RIT Frequency",       "RIT Status",               "RIT TX Status",        "Selected Freq",        "Unselected Freq",
+"Selected Mode",        "Unselected Mode",      "Main RX Frequency",        "Sub RX Frequency",     "Main RX Mode",         "Sub RX Mode",
+"Scope Main Wave Data", "Scope Sub Wave Data",  "Scope On/Off",             "Scope Data Output",
 "Scope Main/Sub",       "Scope Single/Dual",    "Scope Main Mode",          "Scope Sub Mode",       "Scope Main Span",      "Scope Sub Span",
 "Scope Main Edge",      "Scope Sub Edge",       "Scope Main Hold",          "Scope Sub Hold",       "Scope Main Ref",       "Scope Sub Ref",
 "Scope Main Speed",     "Scope Sub Speed",      "Scope Main VBW",           "Scope Sub VBW",        "Scope Main RBW",       "Scope Sub RBW",
@@ -326,10 +331,10 @@ struct funcType {
     bool cmd29;
 };
 
-struct commandtype {
-    cmds cmd;
-    std::shared_ptr<void> data;
-};
+//struct commandtype {
+//    cmds cmd;
+//    std::shared_ptr<void> data;
+//};
 
 struct stepType {
     stepType(){};
@@ -432,12 +437,12 @@ enum usbFeatureType { featureReset,featureResetKeys, featureEventsA, featureEven
 
 struct periodicType {
     periodicType() {};
-    periodicType(funcs func, QString priority, char vfo) : func(func), priority(priority), prioVal(0), vfo(vfo) {};
-    periodicType(funcs func, QString priority, int prioVal, char vfo) : func(func), priority(priority), prioVal(prioVal), vfo(vfo) {};
+    periodicType(funcs func, QString priority, char receiver) : func(func), priority(priority), prioVal(0), receiver(receiver) {};
+    periodicType(funcs func, QString priority, int prioVal, char receiver) : func(func), priority(priority), prioVal(prioVal), receiver(receiver) {};
     funcs func;
     QString priority;
     int prioVal;
-    char vfo;
+    char receiver;
 };
 
 inline QString getMeterDebug(meter_t m) {
@@ -497,7 +502,7 @@ Q_DECLARE_METATYPE(duplexMode_t)
 Q_DECLARE_METATYPE(rptAccessTxRx_t)
 Q_DECLARE_METATYPE(rptrAccessData)
 Q_DECLARE_METATYPE(usbFeatureType)
-Q_DECLARE_METATYPE(cmds)
+//Q_DECLARE_METATYPE(cmds)
 Q_DECLARE_METATYPE(funcs)
 Q_DECLARE_METATYPE(memoryType)
 Q_DECLARE_METATYPE(antennaInfo)