diff --git a/rigcommander.cpp b/rigcommander.cpp
index ed75bf9..c161171 100644
--- a/rigcommander.cpp
+++ b/rigcommander.cpp
@@ -22,20 +22,16 @@
 
 rigCommander::rigCommander()
 {
-    rigState.mutex = new QMutex();
-    QMutexLocker locker(rigState.mutex);
-    rigState.filter = 0;
-    rigState.mode = 0;
-    rigState.ptt = 0;
-    rigState.currentVfo = 0;
-    rigState.duplex = dmSplitOff;
-
+    state.filter(0,NONE);
+    state.mode(0,NONE);
+    state.ptt(0,NONE);
+    state.currentVfo(0,NONE);
+    state.duplex(dmSplitOff,NONE);
 }
 
 rigCommander::~rigCommander()
 {
     closeComm();
-    delete rigState.mutex;
 }
 
 
@@ -572,16 +568,12 @@ void rigCommander::setFrequency(unsigned char vfo, freqt freq)
 
     cmdPayload.append(freqPayload);
     if (vfo == 0) {
-        rigState.mutex->lock();
-        rigState.vfoAFreq = freq;
-        rigState.mutex->unlock();
+        state.vfoAFreq(freq.Hz,NONE);
         cmdPayload.prepend('\x00');
     }
     else
     {   
-        rigState.mutex->lock();
-        rigState.vfoBFreq = freq;
-        rigState.mutex->unlock();
+        state.vfoBFreq(freq.Hz,NONE);
         cmdPayload.prepend(vfo);
         cmdPayload.prepend('\x25');
     }
@@ -709,10 +701,6 @@ void rigCommander::setMode(mode_info m)
     payload.append(m.filter);
 
     prepDataAndSend(payload);
-
-    QMutexLocker locker(rigState.mutex);
-    rigState.mode = m.reg;
-    rigState.filter = m.filter;
 }
 
 void rigCommander::setMode(unsigned char mode, unsigned char modeFilter)
@@ -742,10 +730,6 @@ void rigCommander::setMode(unsigned char mode, unsigned char modeFilter)
         }
 
         prepDataAndSend(payload);
-        QMutexLocker locker(rigState.mutex);
-        rigState.mode = mode;
-        rigState.filter = modeFilter;
-
     }
 }
 
@@ -763,8 +747,6 @@ void rigCommander::setDataMode(bool dataOn, unsigned char filter)
         payload.append("\x00\x00", 2); // data mode off, bandwidth not defined per ICD.
     }
     prepDataAndSend(payload);
-    QMutexLocker locker(rigState.mutex);
-    rigState.datamode = dataOn;
 }
 
 void rigCommander::getFrequency()
@@ -1008,9 +990,9 @@ void rigCommander::getPTT()
     //{
     //    emit havePTTStatus(comm->rtsStatus());
     //} else {
-        QByteArray payload;
-        payload.setRawData("\x1C\x00", 2);
-        prepDataAndSend(payload);
+    QByteArray payload;
+    payload.setRawData("\x1C\x00", 2);
+    prepDataAndSend(payload);
     //}
 }
 
@@ -1031,8 +1013,6 @@ void rigCommander::setPTT(bool pttOn)
         QByteArray payload("\x1C\x00", 2);
         payload.append((char)pttOn);
         prepDataAndSend(payload);
-        QMutexLocker locker(rigState.mutex);
-        rigState.ptt = pttOn;
     }
 }
 
@@ -1253,22 +1233,16 @@ void rigCommander::parseCommand()
             break;
         case '\x0F':
             emit haveDuplexMode((duplexMode)(unsigned char)payloadIn[1]);
-            rigState.mutex->lock();
-            rigState.duplex = (duplexMode)(unsigned char)payloadIn[1];
-            rigState.mutex->unlock();
+            state.duplex((duplexMode)(unsigned char)payloadIn[1],NONE);
             break;
         case '\x11':
             emit haveAttenuator((unsigned char)payloadIn.at(1));
-            rigState.mutex->lock();
-            rigState.attenuator = (unsigned char)payloadIn.at(1);
-            rigState.mutex->unlock();
+            state.attenuator((unsigned char)payloadIn.at(1),NONE);
             break;
         case '\x12':
             emit haveAntenna((unsigned char)payloadIn.at(1), (bool)payloadIn.at(2));
-            rigState.mutex->lock();
-            rigState.antenna = (unsigned char)payloadIn.at(1);
-            rigState.rxAntenna = (bool)payloadIn.at(2);
-            rigState.mutex->unlock();
+            state.antenna((unsigned char)payloadIn.at(1),NONE);
+            state.rxAntenna((bool)payloadIn.at(2),NONE);
             break;
         case '\x14':
             // read levels
@@ -1372,24 +1346,18 @@ void rigCommander::parseLevels()
                 // AF level - ignore if LAN connection.
                 if (udp == Q_NULLPTR) {
                     emit haveAfGain(level);
-                    rigState.mutex->lock();
-                    rigState.afGain = level;
-                    rigState.mutex->unlock();
+                    state.afGain(level,NONE);
                 }
                 break;
             case '\x02':
                 // RX RF Gain
                 emit haveRfGain(level);
-                rigState.mutex->lock();
-                rigState.rfGain = level;
-                rigState.mutex->unlock();
+                state.rfGain(level,NONE);
                 break;
             case '\x03':
                 // Squelch level
-                emit haveSql(level);
-                rigState.mutex->lock();
-                rigState.squelch = level;
-                rigState.mutex->unlock();
+                emit haveSql(level);                
+                state.squelch(level,NONE);
                 break;
             case '\x07':
                 // Twin BPF Inner, or, IF-Shift level
@@ -1408,16 +1376,12 @@ void rigCommander::parseLevels()
             case '\x0A':
                 // TX RF level
                 emit haveTxPower(level);
-                rigState.mutex->lock();
-                rigState.txPower = level;
-                rigState.mutex->unlock();
+                state.txPower(level,NONE);
                 break;
             case '\x0B':
                 // Mic Gain
                 emit haveMicGain(level);
-                rigState.mutex->lock();
-                rigState.micGain = level;
-                rigState.mutex->unlock();
+                state.micGain(level,NONE);
                 break;
             case '\x0C':
                 // CW Keying Speed - ignore for now
@@ -1428,9 +1392,7 @@ void rigCommander::parseLevels()
             case '\x0E':
                 // compressor level
                 emit haveCompLevel(level);
-                rigState.mutex->lock();
-                rigState.compLevel = level;
-                rigState.mutex->unlock();
+                state.compLevel(level,NONE);
                 break;
             case '\x12':
                 // NB level - ignore for now
@@ -1438,23 +1400,17 @@ void rigCommander::parseLevels()
             case '\x15':
                 // monitor level
                 emit haveMonitorLevel(level);
-                rigState.mutex->lock();
-                rigState.monitorLevel = level;
-                rigState.mutex->unlock();
+                state.monitorLevel(level,NONE);
                 break;
             case '\x16':
                 // VOX gain
                 emit haveVoxGain(level);
-                rigState.mutex->lock();
-                rigState.voxGain = level;
-                rigState.mutex->unlock();
+                state.voxGain(level,NONE);
                 break;
             case '\x17':
                 // anti-VOX gain
                 emit haveAntiVoxGain(level);
-                rigState.mutex->lock();
-                rigState.antiVoxGain = level;
-                rigState.mutex->unlock();
+                state.antiVoxGain(level,NONE);
                 break;
 
             default:
@@ -1472,58 +1428,42 @@ void rigCommander::parseLevels()
             case '\x02':
                 // S-Meter
                 emit haveMeter(meterS, level);
-                rigState.mutex->lock();
-                rigState.sMeter = level;
-                rigState.mutex->unlock();
+                state.sMeter(level,NONE);
                 break;
             case '\x04':
                 // Center (IC-R8600)
                 emit haveMeter(meterCenter, level);
-                rigState.mutex->lock();
-                rigState.sMeter = level;
-                rigState.mutex->unlock();
+                state.sMeter(level,NONE);
                 break;
             case '\x11':
                 // RF-Power meter
                 emit haveMeter(meterPower, level);
-                rigState.mutex->lock();
-                rigState.powerMeter = level;
-                rigState.mutex->unlock();
+                state.powerMeter(level,NONE);
                 break;
             case '\x12':
                 // SWR
                 emit haveMeter(meterSWR, level);
-                rigState.mutex->lock();
-                rigState.swrMeter = level;
-                rigState.mutex->unlock();
+                state.swrMeter(level,NONE);
                 break;
             case '\x13':
                 // ALC
                 emit haveMeter(meterALC, level);
-                rigState.mutex->lock();
-                rigState.alcMeter = level;
-                rigState.mutex->unlock();
+                state.alcMeter(level,NONE);
                 break;
             case '\x14':
                 // COMP dB reduction
                 emit haveMeter(meterComp, level);
-                rigState.mutex->lock();
-                rigState.compMeter = level;
-                rigState.mutex->unlock();
+                state.compMeter(level,NONE);
                 break;
             case '\x15':
                 // VD (12V)
                 emit haveMeter(meterVoltage, level);
-                rigState.mutex->lock();
-                rigState.voltageMeter = level;
-                rigState.mutex->unlock();
+                state.voltageMeter(level,NONE);
                 break;
             case '\x16':
                 // ID
                 emit haveMeter(meterCurrent, level);
-                rigState.mutex->lock();
-                rigState.currentMeter = level;
-                rigState.mutex->unlock();
+                state.currentMeter(level,NONE);
                 break;
 
             default:
@@ -2430,8 +2370,7 @@ void rigCommander::parsePTT()
         // PTT on
         emit havePTTStatus(true);
     }
-    QMutexLocker locker(rigState.mutex);
-    rigState.ptt = (bool)payloadIn[2];
+    state.ptt((bool)payloadIn[2],NONE);
 
 }
 
@@ -2450,7 +2389,6 @@ void rigCommander::parseRegisters1A()
 
     // "INDEX: 00 01 02 03 04 "
     // "DATA:  1a 06 01 03 fd " (data mode enabled, filter width 3 selected)
-    QMutexLocker locker(rigState.mutex);
 
     switch(payloadIn[01])
     {
@@ -2461,6 +2399,9 @@ void rigCommander::parseRegisters1A()
             // band stacking register
             parseBandStackReg();
             break;
+        case '\x04':
+            state.agc(payloadIn[02],AGC);
+            break;
         case '\x06':
             // data mode
             // emit havedataMode( (bool) payloadIn[somebit])
@@ -2471,7 +2412,7 @@ void rigCommander::parseRegisters1A()
             // YY: filter selected, 01 through 03.;
             // if YY is 00 then XX was also set to 00
             emit haveDataMode((bool)payloadIn[03]);
-            rigState.datamode = (bool)payloadIn[03];
+            state.datamode((bool)payloadIn[03],NONE);
             break;
         case '\x07':
             // IP+ status
@@ -2493,32 +2434,24 @@ void rigCommander::parseRegister1B()
             // "Repeater tone"
             tone = decodeTone(payloadIn);
             emit haveTone(tone);
-            rigState.mutex->lock();
-            rigState.ctcss = tone;
-            rigState.mutex->unlock();
+            state.ctcss(tone,NONE);
             break;
         case '\x01':
             // "TSQL tone"
             tone = decodeTone(payloadIn);
             emit haveTSQL(tone);
-            rigState.mutex->lock();
-            rigState.tsql = tone;
-            rigState.mutex->unlock();
+            state.tsql(tone,NONE);
             break;
         case '\x02':
             // DTCS (DCS)
             tone = decodeTone(payloadIn, tinv, rinv);
             emit haveDTCS(tone, tinv, rinv);
-            rigState.mutex->lock();
-            rigState.dtcs = tone;
-            rigState.mutex->unlock();
+            state.dtcs(tone,NONE);
             break;
         case '\x07':
             // "CSQL code (DV mode)"
             tone = decodeTone(payloadIn);
-            rigState.mutex->lock();
-            rigState.csql = tone;
-            rigState.mutex->unlock();
+            state.csql(tone,NONE);
             break;
         default:
             break;
@@ -2539,9 +2472,49 @@ void rigCommander::parseRegister16()
         case '\x02':
             // Preamp
             emit havePreamp((unsigned char)payloadIn.at(2));
-            rigState.mutex->lock();
-            rigState.preamp = (unsigned char)payloadIn.at(2);
-            rigState.mutex->unlock();
+            state.preamp((unsigned char)payloadIn.at(2),NONE);
+            break;
+        case '\x22':
+            state.nbFunc((bool)payloadIn.at(2), NONE);
+            break;
+        case '\x40':
+            state.nrFunc((bool)payloadIn.at(2), NONE);
+            break;
+        case '\x41': // Auto notch
+            state.anfFunc((bool)payloadIn.at(2), NONE);
+            break;
+        case '\x42':
+            state.toneFunc((bool)payloadIn.at(2), NONE);
+            break;
+        case '\x43':
+            state.tsqlFunc((bool)payloadIn.at(2), NONE);
+            break;
+        case '\44':
+            state.compFunc((bool)payloadIn.at(2), NONE);
+            break;
+        case '\45':
+            state.monFunc((bool)payloadIn.at(2), NONE);
+            break;
+        case '\46':
+            state.voxFunc((bool)payloadIn.at(2), NONE);
+            break;
+        case '\x47':
+            if (payloadIn.at(2) == '\00') {
+                state.fbkinFunc(false, NONE);
+                state.sbkinFunc(false, NONE);
+            }
+            else if (payloadIn.at(2) == '\01') {
+                state.fbkinFunc(false, NONE);
+                state.sbkinFunc(true, NONE);
+
+            }
+            else if (payloadIn.at(2) == '\02') {
+                state.fbkinFunc(true, NONE);
+                state.sbkinFunc(false, NONE);
+            }
+            break;
+        case '\48': // Manual Notch
+            state.mnFunc((bool)payloadIn.at(2), NONE);
             break;
         default:
             break;
@@ -3815,49 +3788,51 @@ void rigCommander::parseFrequency()
 
     // printHex(payloadIn, false, true);
     frequencyMhz = 0.0;
-    if(payloadIn.length() == 7)
+    if (payloadIn.length() == 7)
     {
         // 7300 has these digits too, as zeros.
         // IC-705 or IC-9700 with higher frequency data available.
-        frequencyMhz += 100*(payloadIn[05] & 0x0f);
-        frequencyMhz += (1000*((payloadIn[05] & 0xf0) >> 4));
+        frequencyMhz += 100 * (payloadIn[05] & 0x0f);
+        frequencyMhz += (1000 * ((payloadIn[05] & 0xf0) >> 4));
 
-        freq.Hz += (payloadIn[05] & 0x0f) * 1E6 *          100;
-        freq.Hz += ((payloadIn[05] & 0xf0) >> 4) * 1E6 *  1000;
+        freq.Hz += (payloadIn[05] & 0x0f) * 1E6 * 100;
+        freq.Hz += ((payloadIn[05] & 0xf0) >> 4) * 1E6 * 1000;
 
     }
 
     freq.Hz += (payloadIn[04] & 0x0f) * 1E6;
-    freq.Hz += ((payloadIn[04] & 0xf0) >> 4) * 1E6 *        10;
+    freq.Hz += ((payloadIn[04] & 0xf0) >> 4) * 1E6 * 10;
 
     frequencyMhz += payloadIn[04] & 0x0f;
-    frequencyMhz += 10*((payloadIn[04] & 0xf0) >> 4);
+    frequencyMhz += 10 * ((payloadIn[04] & 0xf0) >> 4);
 
     // KHz land:
-    frequencyMhz += ((payloadIn[03] & 0xf0) >>4)/10.0 ;
+    frequencyMhz += ((payloadIn[03] & 0xf0) >> 4) / 10.0;
     frequencyMhz += (payloadIn[03] & 0x0f) / 100.0;
 
     frequencyMhz += ((payloadIn[02] & 0xf0) >> 4) / 1000.0;
     frequencyMhz += (payloadIn[02] & 0x0f) / 10000.0;
 
-    frequencyMhz += ((payloadIn[01] & 0xf0) >> 4) /  100000.0;
-    frequencyMhz += (payloadIn[01] & 0x0f)        / 1000000.0;
+    frequencyMhz += ((payloadIn[01] & 0xf0) >> 4) / 100000.0;
+    frequencyMhz += (payloadIn[01] & 0x0f) / 1000000.0;
 
     freq.Hz += payloadIn[01] & 0x0f;
-    freq.Hz += ((payloadIn[01] & 0xf0) >> 4)*      10;
+    freq.Hz += ((payloadIn[01] & 0xf0) >> 4) * 10;
 
-    freq.Hz  += (payloadIn[02] & 0x0f) *           100;
-    freq.Hz  += ((payloadIn[02] & 0xf0) >> 4) *   1000;
+    freq.Hz += (payloadIn[02] & 0x0f) * 100;
+    freq.Hz += ((payloadIn[02] & 0xf0) >> 4) * 1000;
 
-    freq.Hz  += (payloadIn[03] & 0x0f) *         10000;
-    freq.Hz  += ((payloadIn[03] & 0xf0) >>4) *  100000;
+    freq.Hz += (payloadIn[03] & 0x0f) * 10000;
+    freq.Hz += ((payloadIn[03] & 0xf0) >> 4) * 100000;
 
     freq.MHzDouble = frequencyMhz;
 
-    rigState.mutex->lock();
-    rigState.vfoAFreq = freq;
-    rigState.mutex->unlock();
-
+    if (state.currentVfo() == 0) {
+        state.vfoAFreq(freq.Hz, NONE);
+    }
+    else {
+        state.vfoBFreq(freq.Hz, NONE);
+    }
     emit haveFrequency(freq);
 }
 
@@ -3935,11 +3910,9 @@ void rigCommander::parseMode()
     } else {
         filter = 0;
     }
-    rigState.mutex->lock();
-    rigState.mode = (unsigned char)payloadIn[01];
-    rigState.filter = filter;
-    rigState.mutex->unlock();
     emit haveMode((unsigned char)payloadIn[01], filter);
+    state.mode((unsigned char)payloadIn[01],NONE);
+    state.filter(filter,NONE);
 }
 
 
@@ -4014,6 +3987,144 @@ void rigCommander::setAntenna(unsigned char ant, bool rx)
     prepDataAndSend(payload);
 }
 
+void rigCommander::setNb(bool enabled) {
+    QByteArray payload("\x16\x22");
+    payload.append((unsigned char)enabled);
+    prepDataAndSend(payload);
+}
+
+void rigCommander::getNb()
+{
+    QByteArray payload;
+    payload.setRawData("\x16\x22", 2);
+    prepDataAndSend(payload);
+}
+
+void rigCommander::setNr(bool enabled) {
+    QByteArray payload("\x16\x40");
+    payload.append((unsigned char)enabled);
+    prepDataAndSend(payload);
+}
+
+void rigCommander::getNr()
+{
+    QByteArray payload;
+    payload.setRawData("\x16\x40", 2);
+    prepDataAndSend(payload);
+}
+
+void rigCommander::setAutoNotch(bool enabled)
+{
+    QByteArray payload("\x16\x41");
+    payload.append((unsigned char)enabled);
+    prepDataAndSend(payload);
+}
+
+void rigCommander::getAutoNotch()
+{
+    QByteArray payload;
+    payload.setRawData("\x16\x41", 2);
+    prepDataAndSend(payload);
+}
+
+void rigCommander::setToneEnabled(bool enabled)
+{
+    QByteArray payload("\x16\x42");
+    payload.append((unsigned char)enabled);
+    prepDataAndSend(payload);
+}
+
+void rigCommander::getToneEnabled()
+{
+    QByteArray payload;
+    payload.setRawData("\x16\x42", 2);
+    prepDataAndSend(payload);
+}
+
+void rigCommander::setToneSql(bool enabled)
+{
+    QByteArray payload("\x16\x43");
+    payload.append((unsigned char)enabled);
+    prepDataAndSend(payload);
+}
+
+void rigCommander::getToneSql()
+{
+    QByteArray payload;
+    payload.setRawData("\x16\x43", 2);
+    prepDataAndSend(payload);
+}
+
+void rigCommander::setCompressor(bool enabled)
+{
+    QByteArray payload("\x16\x44");
+    payload.append((unsigned char)enabled);
+    prepDataAndSend(payload);
+}
+
+void rigCommander::getCompressor()
+{
+    QByteArray payload;
+    payload.setRawData("\x16\x44", 2);
+    prepDataAndSend(payload);
+}
+
+void rigCommander::setMonitor(bool enabled)
+{
+    QByteArray payload("\x16\x45");
+    payload.append((unsigned char)enabled);
+    prepDataAndSend(payload);
+}
+
+void rigCommander::getMonitor()
+{
+    QByteArray payload;
+    payload.setRawData("\x16\x45", 2);
+    prepDataAndSend(payload);
+}
+
+void rigCommander::setVox(bool enabled)
+{
+    QByteArray payload("\x16\x46");
+    payload.append((unsigned char)enabled);
+    prepDataAndSend(payload);
+}
+
+void rigCommander::getVox()
+{
+    QByteArray payload;
+    payload.setRawData("\x16\x46", 2);
+    prepDataAndSend(payload);
+}
+
+void rigCommander::setBreakIn(unsigned char type) {
+    QByteArray payload("\x16\x47");
+    payload.append((unsigned char)type);
+    prepDataAndSend(payload);
+}
+
+void rigCommander::getBreakIn()
+{
+    QByteArray payload;
+    payload.setRawData("\x16\x47", 2);
+    prepDataAndSend(payload);
+}
+
+void rigCommander::setManualNotch(bool enabled)
+{
+    QByteArray payload("\x16\x48");
+    payload.append((unsigned char)enabled);
+    prepDataAndSend(payload);
+}
+
+void rigCommander::getManualNotch()
+{
+    QByteArray payload;
+    payload.setRawData("\x16\x48", 2);
+    prepDataAndSend(payload);
+}
+
+
 void rigCommander::getRigID()
 {
     QByteArray payload;
@@ -4086,7 +4197,185 @@ QByteArray rigCommander::stripData(const QByteArray &data, unsigned char cutPosi
 
 void rigCommander::sendState()
 {
-    emit stateInfo(&rigState);
+    emit stateInfo(&state);
+}
+
+void rigCommander::stateUpdated()
+{
+    // A remote process has updated the rigState
+    // First we need to find which item(s) have been updated and send the command(s) to the rig.
+    /*
+       FAGCFUNC, NBFUNC, COMPFUNC, VOXFUNC, TONEFUNC, TSQLFUNC, SBKINFUNC, FBKINFUNC, ANFFUNC, NRFUNC, AIPFUNC, APFFUNC, MONFUNC, MNFUNC,RFFUNC,
+       AROFUNC, MUTEFUNC, VSCFUNC, REVFUNC, SQLFUNC, ABMFUNC, BCFUNC, MBCFUNC, RITFUNC, AFCFUNC, SATMODEFUNC, SCOPEFUNC,
+       RESUMEFUNC, TBURSTFUNC, TUNERFUNC};
+    */
+
+        /* VFOAFREQ, VFOBFREQ, CURRENTVFO, PTT, MODE, FILTER, DUPLEX, DATAMODE, ANTENNA, RXANTENNA, CTCSS, TSQL, DTCS, CSQL */
+
+        if ((state.updated()) & (1ULL <<(VFOAFREQ))) {
+        // VFO A FREQUENCY IS UPDATED!
+        freqt freq;
+        freq.Hz = state.vfoAFreq();
+        setFrequency(0, freq);
+        setFrequency(0, freq);
+        setFrequency(0, freq);
+        getFrequency();
+
+    }
+    if ((state.updated()) & (1ULL <<(VFOBFREQ))) {
+        // VFO B FREQUENCY IS UPDATED!
+        freqt freq;
+        freq.Hz = state.vfoBFreq();
+        setFrequency(1, freq);
+        setFrequency(1, freq);
+        setFrequency(1, freq);
+        getFrequency();
+    }
+    if ((state.updated()) & (1ULL <<(CURRENTVFO))) {
+        // Work on VFOB - how do we do this?
+    }
+    if ((state.updated()) & (1ULL <<(PTT))) {
+        setPTT(state.ptt());
+        setPTT(state.ptt());
+        setPTT(state.ptt());
+        getPTT();
+    }
+    if (((state.updated()) & (1ULL <<(MODE))) || ((state.updated()) & (1ULL <<(FILTER)))) {
+        setMode(state.mode(),state.filter());
+        getMode();
+    }
+
+    if ((state.updated()) & (1ULL <<(DUPLEX))) {
+        setDuplexMode(state.duplex());
+        getDuplexMode();
+    }
+
+    if ((state.updated()) & (1ULL <<(DATAMODE))) {
+        setDataMode(state.datamode(), state.filter());
+        getDataMode();
+    }
+
+    if (((state.updated()) & (1ULL <<(ANTENNA))) || ((state.updated()) & (1ULL <<(RXANTENNA)))) {
+        setAntenna(state.antenna(), state.rxAntenna());
+        getAntenna();
+    }
+
+    if ((state.updated()) & (1ULL <<(CTCSS))) {
+        setTone(state.ctcss());
+        getTone();
+    }
+    if ((state.updated()) & (1ULL <<(TSQL))) {
+        setTSQL(state.tsql());
+        getTSQL();
+    }
+    if ((state.updated()) & (1ULL <<(DTCS))) {
+        setDTCS(state.dtcs(),false,false); // Not sure about this?
+        getDTCS();
+    }
+    if ((state.updated()) & (1ULL <<(CSQL))) { // Not sure about this one?
+        //setTone(state.ctcss());
+        //getTone();
+    }
+
+    /* PREAMP, ATTENUATOR, MODINPUT, AFGAIN, RFGAIN, SQUELCH, TXPOWER, MICGAIN, COMPLEVEL, MONITORLEVEL, VOXGAIN, ANTIVOXGAIN */
+    if ((state.updated()) & (1ULL <<(PREAMP))) { 
+        setPreamp(state.preamp());
+        getPreamp();
+    }
+    if ((state.updated()) & (1ULL <<(ATTENUATOR))) { 
+        setAttenuator(state.attenuator());
+        getAttenuator();
+    }
+    if ((state.updated()) & (1ULL <<(MODINPUT))) { 
+        getModInputLevel(rigInput::inputLAN); // Need to fix this!
+    }
+
+    if ((state.updated()) & (1ULL <<(AFGAIN))) {
+        setAfGain(state.afGain());
+        getAfGain();
+    }
+
+    if ((state.updated()) & (1ULL <<(RFGAIN))) {
+        setRfGain(state.rfGain());
+        getRfGain();
+    }
+
+    if ((state.updated()) & (1ULL <<(SQUELCH))) {
+        setSquelch(state.squelch());
+        getSql();
+    }
+
+    if ((state.updated()) & (1ULL <<(TXPOWER))) {
+        setTxPower(state.txPower());
+        getTxLevel();
+    }
+
+    if ((state.updated()) & (1ULL <<(MICGAIN))) {
+        setMicGain(state.micGain());
+        getMicGain();
+    }
+
+    if ((state.updated()) & (1ULL <<(COMPLEVEL))) {
+        setCompLevel(state.compLevel());
+        getCompLevel();
+    }
+
+    if ((state.updated()) & (1ULL <<(MONITORLEVEL))) {
+        setMonitorLevel(state.monitorLevel());
+        getMonitorLevel();
+    }
+
+    if ((state.updated()) & (1ULL <<(VOXGAIN))) {
+        setVoxGain(state.voxGain());
+        getVoxGain();
+    }
+
+    if ((state.updated()) & (1ULL <<(ANTIVOXGAIN))) {
+        setAntiVoxGain(state.antiVoxGain());
+        getAntiVoxGain();
+    }
+    if ((state.updated()) & (1ULL <<(NBFUNC))) {
+        setNb(state.nbFunc());
+        getNb();
+    }
+    if ((state.updated()) & (1ULL << (NRFUNC))) {
+        setNr(state.nrFunc());
+        getNr();
+    }
+    if ((state.updated()) & (1ULL << (ANFFUNC))) {
+        setAutoNotch(state.anfFunc());
+        getAutoNotch();
+    }
+    if ((state.updated()) & (1ULL << (TONEFUNC))) {
+        setToneEnabled(state.toneFunc());
+        getToneEnabled();
+    }
+    if ((state.updated()) & (1ULL << (TSQLFUNC))) {
+        setToneSql(state.tsqlFunc());
+        getToneSql();
+    }
+    if ((state.updated()) & (1ULL << (COMPFUNC))) {
+        setCompressor(state.compFunc());
+        getCompressor();
+    }
+    if ((state.updated()) & (1ULL << (MONFUNC))) {
+        setMonitor(state.monFunc());
+        getMonitor();
+    }
+    if ((state.updated()) & (1ULL << (VOXFUNC))) {
+        setVox(state.voxFunc());
+        getVox();
+    }
+    if ((state.updated()) & (1ULL <<(FBKINFUNC))) {
+        setBreakIn(state.sbkinFunc()<<1);
+        getBreakIn();
+    }
+    if ((state.updated()) & (1ULL << (MNFUNC))) {
+        setManualNotch(state.mnFunc());
+        getManualNotch();
+    }
+
+    state.updated(0);
 }
 
 void rigCommander::getDebug()
diff --git a/rigcommander.h b/rigcommander.h
index 90550e0..de1f4a1 100644
--- a/rigcommander.h
+++ b/rigcommander.h
@@ -2,10 +2,10 @@
 #define RIGCOMMANDER_H
 
 #include <QObject>
-#include <QMutex>
 #include <QMutexLocker>
 #include <QDebug>
 
+
 #include "commhandler.h"
 #include "pttyhandler.h"
 #include "udphandler.h"
@@ -13,6 +13,8 @@
 #include "repeaterattributes.h"
 #include "freqmemory.h"
 
+#include "rigstate.h"
+
 // This file figures out what to send to the comm and also
 // parses returns into useful things.
 
@@ -61,78 +63,6 @@ struct timekind {
     bool isMinus;
 };
 
-struct rigStateStruct {
-    QMutex *mutex;
-    freqt vfoAFreq;
-    freqt vfoBFreq;
-    unsigned char currentVfo;
-    bool ptt;
-    unsigned char mode;
-    unsigned char filter;
-    duplexMode duplex;
-    bool datamode;
-    unsigned char antenna;
-    bool rxAntenna;
-    // Tones
-    quint16 ctcss;
-    quint16 tsql;
-    quint16 dtcs;
-    quint16 csql;
-    // Levels
-    unsigned char preamp;
-    unsigned char attenuator;
-    unsigned char modInput;
-    unsigned char afGain;
-    unsigned char rfGain;
-    unsigned char squelch;
-    unsigned char txPower;
-    unsigned char micGain;
-    unsigned char compLevel;
-    unsigned char monitorLevel;
-    unsigned char voxGain;
-    unsigned char antiVoxGain;
-    // Meters
-    unsigned char sMeter;
-    unsigned char powerMeter;
-    unsigned char swrMeter;
-    unsigned char alcMeter;
-    unsigned char compMeter;
-    unsigned char voltageMeter;
-    unsigned char currentMeter;
-    // Functions
-    bool fagcFunc=false;
-    bool nbFunc=false;
-    bool compFunc=false;
-    bool voxFunc = false;
-    bool toneFunc = false;
-    bool tsqlFunc = false;
-    bool sbkinFunc = false;
-    bool fbkinFunc = false;
-    bool anfFunc = false;
-    bool nrFunc = false;
-    bool aipFunc = false;
-    bool apfFunc = false;
-    bool monFunc = false;
-    bool mnFunc = false;
-    bool rfFunc = false;
-    bool aroFunc = false;
-    bool muteFunc = false;
-    bool vscFunc = false;
-    bool revFunc = false;
-    bool sqlFunc = false;
-    bool abmFunc = false;
-    bool bcFunc = false;
-    bool mbcFunc = false;
-    bool ritFunc = false;
-    bool afcFunc = false;
-    bool satmodeFunc = false;
-    bool scopeFunc = false;
-    bool resumeFunc = false;
-    bool tburstFunc = false;
-    bool tunerFunc = false;
-    bool lockFunc = false;
-};
-
 class rigCommander : public QObject
 {
     Q_OBJECT
@@ -148,6 +78,7 @@ public slots:
     void commSetup(unsigned char rigCivAddr, QString rigSerialPort, quint32 rigBaudRate,QString vsp);
     void commSetup(unsigned char rigCivAddr, udpPreferences prefs, audioSetup rxSetup, audioSetup txSetup, QString vsp);
     void closeComm();
+    void stateUpdated();
 
     // Power:
     void powerOn();
@@ -199,6 +130,26 @@ public slots:
     void setAttenuator(unsigned char att);
     void setPreamp(unsigned char pre);
     void setAntenna(unsigned char ant, bool rx);
+    void setNb(bool enabled);
+    void getNb();
+    void setNr(bool enabled);
+    void getNr();
+    void setAutoNotch(bool enabled);
+    void getAutoNotch();
+    void setToneEnabled(bool enabled);
+    void getToneEnabled();
+    void setToneSql(bool enabled);
+    void getToneSql();
+    void setCompressor(bool enabled);
+    void getCompressor();
+    void setMonitor(bool enabled);
+    void getMonitor();
+    void setVox(bool enabled);
+    void getVox();
+    void setBreakIn(unsigned char type);
+    void getBreakIn();
+    void setManualNotch(bool enabled);
+    void getManualNotch();
 
     // Repeater:
     void setDuplexMode(duplexMode dm);
@@ -406,7 +357,7 @@ signals:
     void haveAntenna(unsigned char ant,bool rx);
 
     // Rig State
-    void stateInfo(rigStateStruct* state);
+    void stateInfo(rigstate* state);
 
     // Housekeeping:
     void getMoreDebug();
@@ -480,7 +431,7 @@ private:
 
     struct rigCapabilities rigCaps;
     
-    rigStateStruct rigState;
+    rigstate state;
 
     bool haveRigCaps;
     model_kind model;
diff --git a/rigctld.cpp b/rigctld.cpp
index c456cbd..ebceb3b 100644
--- a/rigctld.cpp
+++ b/rigctld.cpp
@@ -61,7 +61,7 @@ rigCtlD::~rigCtlD()
 //    emit setFrequency(0, freq);
 //}
 
-void rigCtlD::receiveStateInfo(rigStateStruct* state)
+void rigCtlD::receiveStateInfo(rigstate* state)
 {
     qInfo("Setting rig state");
     rigState = state;
@@ -100,7 +100,7 @@ void rigCtlD::receiveRigCaps(rigCapabilities caps)
     this->rigCaps = caps;
 }
 
-rigCtlClient::rigCtlClient(int socketId, rigCapabilities caps, rigStateStruct* state, rigCtlD* parent) : QObject(parent)
+rigCtlClient::rigCtlClient(int socketId, rigCapabilities caps, rigstate* state, rigCtlD* parent) : QObject(parent)
 {
 
     commandBuffer.clear();
@@ -132,7 +132,7 @@ void rigCtlClient::socketReadyRead()
     bool setCommand = false;
     if (commandBuffer.endsWith('\n'))
     {
-        qDebug(logRigCtlD()) << sessionId << "command received" << commandBuffer;
+        //qDebug(logRigCtlD()) << sessionId << "command received" << commandBuffer;
         commandBuffer.chop(1); // Remove \n character
         if (commandBuffer.endsWith('\r'))
         {
@@ -175,7 +175,6 @@ void rigCtlClient::socketReadyRead()
 
         QStringList command = commandBuffer.mid(num).split(" ");
 
-        QMutexLocker locker(rigState->mutex);
 
         if (command[0] == 0xf0 || command[0] == "chk_vfo")
         {
@@ -183,7 +182,7 @@ void rigCtlClient::socketReadyRead()
             if (longReply) {
                 resp.append(QString("ChkVFO: "));
             }
-            resp.append(QString("%1").arg(rigState->currentVfo));
+            resp.append(QString("%1").arg(rigState->currentVfo()));
             response.append(resp);
         }
         else if (command[0] == "dump_state")
@@ -276,11 +275,11 @@ void rigCtlClient::socketReadyRead()
             if (longReply) {
                 resp.append(QString("Frequency: "));
             }
-            if (rigState->currentVfo == 0) {
-                resp.append(QString("%1").arg(rigState->vfoAFreq.Hz));
+            if (rigState->currentVfo()==0) {
+                resp.append(QString("%1").arg(rigState->vfoAFreq()));
             }
             else {
-                resp.append(QString("%1").arg(rigState->vfoBFreq.Hz));
+                resp.append(QString("%1").arg(rigState->vfoBFreq()));
             }
             response.append(resp);
         }
@@ -307,11 +306,12 @@ void rigCtlClient::socketReadyRead()
             if (ok) {
                 freq.Hz = static_cast<int>(newFreq);
                 qDebug(logRigCtlD()) << QString("Set frequency: %1 (%2)").arg(freq.Hz).arg(command[1]);
-                emit parent->setFrequency(vfo, freq);
-                emit parent->setFrequency(vfo, freq);
-                emit parent->setFrequency(vfo, freq);
-                emit parent->setFrequency(vfo, freq);
-                emit parent->setFrequency(vfo, freq);
+                if (vfo == 0) {
+                    rigState->vfoAFreq(freq.Hz, VFOAFREQ);
+                }
+                else {
+                    rigState->vfoAFreq(freq.Hz, VFOBFREQ);
+                }
             }
         }
         else if (command[0] == "1" || command[0] == "dump_caps")
@@ -341,7 +341,7 @@ void rigCtlClient::socketReadyRead()
                 if (longReply) {
                     resp.append(QString("PTT: "));
                 }
-                resp.append(QString("%1").arg(rigState->ptt));
+                resp.append(QString("%1").arg(rigState->ptt()));
                 response.append(resp);
             }
             else
@@ -353,11 +353,7 @@ void rigCtlClient::socketReadyRead()
         {
             setCommand = true;
             if (rigCaps.hasPTTCommand) {
-                emit parent->setPTT(bool(command[1].toInt()));
-                emit parent->setPTT(bool(command[1].toInt()));
-                emit parent->setPTT(bool(command[1].toInt()));
-                emit parent->setPTT(bool(command[1].toInt()));
-                emit parent->setPTT(bool(command[1].toInt()));
+                rigState->ptt(bool(command[1].toInt()), PTT);
             }
             else
             {
@@ -371,7 +367,7 @@ void rigCtlClient::socketReadyRead()
                 resp.append("VFO: ");
             }
 
-            if (rigState->currentVfo == 0) {
+            if (rigState->currentVfo() == 0) {
                 resp.append("VFOA");
             }
             else {
@@ -400,10 +396,10 @@ void rigCtlClient::socketReadyRead()
         else if (command[0] == "s" || command[0] == "get_split_vfo")
         {
             if (longReply) {
-                response.append(QString("Split: %1").arg(rigState->duplex));
+                response.append(QString("Split: %1").arg(rigState->duplex()));
             }
             else {
-                response.append(QString("%1").arg(rigState->duplex));
+                response.append(QString("%1").arg(rigState->duplex()));
             }
 
             QString resp;
@@ -411,7 +407,7 @@ void rigCtlClient::socketReadyRead()
                 resp.append("TX VFO: ");
             }
 
-            if (rigState->currentVfo == 0)
+            if (rigState->currentVfo() == 0)
             {
                 resp.append(QString("%1").arg("VFOB"));
             }
@@ -425,12 +421,10 @@ void rigCtlClient::socketReadyRead()
             setCommand = true;
             if (command[1] == "1")
             {
-                emit parent->setDuplexMode(dmSplitOn);
-                rigState->duplex = dmSplitOn;
+                rigState->duplex(dmSplitOn, DUPLEX);
             }
             else {
-                emit parent->setDuplexMode(dmSplitOff);
-                rigState->duplex = dmSplitOff;
+                rigState->duplex(dmSplitOff, DUPLEX);
             }
         }
         else if (command[0] == "\xf3" || command[0] == "get_vfo_info")
@@ -439,25 +433,25 @@ void rigCtlClient::socketReadyRead()
                 //response.append(QString("set_vfo: %1").arg(command[1]));
 
                 if (command[1] == "VFOB") {
-                    response.append(QString("Freq: %1").arg(rigState->vfoBFreq.Hz));
+                    response.append(QString("Freq: %1").arg(rigState->vfoBFreq()));
                 }
                 else {
-                    response.append(QString("Freq: %1").arg(rigState->vfoAFreq.Hz));
+                    response.append(QString("Freq: %1").arg(rigState->vfoAFreq()));
                 }
-                response.append(QString("Mode: %1").arg(getMode(rigState->mode, rigState->datamode)));
-                response.append(QString("Width: %1").arg(getFilter(rigState->mode, rigState->filter)));
-                response.append(QString("Split: %1").arg(rigState->duplex));
+                response.append(QString("Mode: %1").arg(getMode(rigState->mode(), rigState->datamode())));
+                response.append(QString("Width: %1").arg(getFilter(rigState->mode(), rigState->filter())));
+                response.append(QString("Split: %1").arg(rigState->duplex()));
                 response.append(QString("SatMode: %1").arg(0)); // Need to get satmode 
             }
             else {
                 if (command[1] == "VFOB") {
-                    response.append(QString("%1").arg(rigState->vfoBFreq.Hz));
+                    response.append(QString("%1").arg(rigState->vfoBFreq()));
                 }
                 else {
-                    response.append(QString("%1").arg(rigState->vfoAFreq.Hz));
+                    response.append(QString("%1").arg(rigState->vfoAFreq()));
                 }
-                response.append(QString("%1").arg(getMode(rigState->mode, rigState->datamode)));
-                response.append(QString("%1").arg(getFilter(rigState->mode, rigState->filter)));
+                response.append(QString("%1").arg(getMode(rigState->mode(), rigState->datamode())));
+                response.append(QString("%1").arg(getFilter(rigState->mode(), rigState->filter())));
             }
         }
         else if (command[0] == "i" || command[0] == "get_split_freq")
@@ -466,56 +460,51 @@ void rigCtlClient::socketReadyRead()
             if (longReply) {
                 resp.append("TX VFO: ");
             }
-            if (rigState->currentVfo == 0) {
-                resp.append(QString("%1").arg(rigState->vfoBFreq.Hz));
+            if (rigState->currentVfo() == 0) {
+                resp.append(QString("%1").arg(rigState->vfoBFreq()));
             }
             else {
-                resp.append(QString("%1").arg(rigState->vfoAFreq.Hz));
+                resp.append(QString("%1").arg(rigState->vfoAFreq()));
             }
             response.append(resp);
         }
         else if (command.length() > 1 && (command[0] == "I" || command[0] == "set_split_freq"))
         {
             setCommand = true;
-            freqt freq;
             bool ok = false;
             double newFreq = 0.0f;
             newFreq = command[1].toDouble(&ok);
             if (ok) {
-                freq.Hz = static_cast<int>(newFreq);
-                qDebug(logRigCtlD()) << QString("set_split_freq: %1 (%2)").arg(freq.Hz).arg(command[1]);
-                emit parent->setFrequency(1, freq);
-                emit parent->setFrequency(1, freq);
-                emit parent->setFrequency(1, freq);
-                emit parent->setFrequency(1, freq);
-                emit parent->setFrequency(1, freq);
+                qDebug(logRigCtlD()) << QString("set_split_freq: %1 (%2)").arg(newFreq).arg(command[1]);
+                rigState->vfoBFreq(static_cast<int>(newFreq),VFOBFREQ);
             }
         }
         else if (command.length() > 2 && (command[0] == "X" || command[0] == "set_split_mode"))
         {
             setCommand = true;
-            }
-            else if (command.length() > 0 && (command[0] == "x" || command[0] == "get_split_mode"))
-            {
+        }
+            
+        else if (command.length() > 0 && (command[0] == "x" || command[0] == "get_split_mode"))
+        {
             if (longReply) {
-                response.append(QString("TX Mode: %1").arg(getMode(rigState->mode, rigState->datamode)));
-                response.append(QString("TX Passband: %1").arg(getFilter(rigState->mode, rigState->filter)));
+                response.append(QString("TX Mode: %1").arg(getMode(rigState->mode(), rigState->datamode())));
+                response.append(QString("TX Passband: %1").arg(getFilter(rigState->mode(), rigState->filter())));
             }
             else {
-                response.append(QString("%1").arg(getMode(rigState->mode, rigState->datamode)));
-                response.append(QString("%1").arg(getFilter(rigState->mode, rigState->filter)));
+                response.append(QString("%1").arg(getMode(rigState->mode(), rigState->datamode())));
+                response.append(QString("%1").arg(getFilter(rigState->mode(), rigState->filter())));
             }
         }
 
         else if (command[0] == "m" || command[0] == "get_mode")
         {
         if (longReply) {
-            response.append(QString("Mode: %1").arg(getMode(rigState->mode, rigState->datamode)));
-            response.append(QString("Passband: %1").arg(getFilter(rigState->mode, rigState->filter)));
+            response.append(QString("Mode: %1").arg(getMode(rigState->mode(), rigState->datamode())));
+            response.append(QString("Passband: %1").arg(getFilter(rigState->mode(), rigState->filter())));
         }
         else {
-            response.append(QString("%1").arg(getMode(rigState->mode, rigState->datamode)));
-            response.append(QString("%1").arg(getFilter(rigState->mode, rigState->filter)));
+            response.append(QString("%1").arg(getMode(rigState->mode(), rigState->datamode())));
+            response.append(QString("%1").arg(getFilter(rigState->mode(), rigState->filter())));
         }
         }
         else if (command[0] == "M" || command[0] == "set_mode")
@@ -541,14 +530,13 @@ void rigCtlClient::socketReadyRead()
             else
                 width = 1;
 
-            emit parent->setMode(getMode(mode), width);
+            rigState->mode(getMode(mode), MODE);
+            rigState->filter(width, FILTER);
             if (mode.mid(0, 3) == "PKT") {
-                emit parent->setDataMode(true, width);
-                emit parent->setDataMode(true, width);
+                rigState->datamode(true, DATAMODE);
             }
             else {
-                emit parent->setDataMode(false, width);
-                emit parent->setDataMode(false, width);
+                rigState->datamode(true, DATAMODE);
             }
         }
         else if (command[0] == "s" || command[0] == "get_split_vfo")
@@ -585,34 +573,35 @@ void rigCtlClient::socketReadyRead()
                 if (longReply) {
                     response.append(QString("AntCurr: %1").arg(getAntName((unsigned char)command[1].toInt())));
                     response.append(QString("Option: %1").arg(0));
-                    response.append(QString("AntTx: %1").arg(getAntName(rigState->antenna)));
-                    response.append(QString("AntRx: %1").arg(getAntName(rigState->antenna)));
+                    response.append(QString("AntTx: %1").arg(getAntName(rigState->antenna())));
+                    response.append(QString("AntRx: %1").arg(getAntName(rigState->antenna())));
                 }
                 else {
                     response.append(QString("%1").arg(getAntName((unsigned char)command[1].toInt())));
                     response.append(QString("%1").arg(0));
-                    response.append(QString("%1").arg(getAntName(rigState->antenna)));
-                    response.append(QString("%1").arg(getAntName(rigState->antenna)));
+                    response.append(QString("%1").arg(getAntName(rigState->antenna())));
+                    response.append(QString("%1").arg(getAntName(rigState->antenna())));
                 }
             }
         }
         else if (command[0] == "Y" || command[0] == "set_ant")
         {
-        qInfo(logRigCtlD()) << "set_ant:";
-        setCommand = true;
+            setCommand = true;
+            qInfo(logRigCtlD()) << "set_ant:" << command[1];
+            rigState->antenna(antFromName(command[1]),ANTENNA);
         }
         else if (command[0] == "z" || command[0] == "get_xit")
         {
-        QString resp;
-        if (longReply) {
-            resp.append("XIT: ");
-        }
-        resp.append(QString("%1").arg(0));
-        response.append(resp);
+            QString resp;
+            if (longReply) {
+                resp.append("XIT: ");
+            }
+            resp.append(QString("%1").arg(0));
+            response.append(resp);
         }
         else if (command[0] == "Z" || command[0] == "set_xit")
         {
-        setCommand = true;
+            setCommand = true;
         }
         else if (command.length() > 1 && (command[0] == "l" || command[0] == "get_level"))
         {
@@ -624,46 +613,46 @@ void rigCtlClient::socketReadyRead()
 
             if (command[1] == "STRENGTH") {
                 if (rigCaps.model == model7610)
-                    value = getCalibratedValue(rigState->sMeter, IC7610_STR_CAL);
+                    value = getCalibratedValue(rigState->sMeter(), IC7610_STR_CAL);
                 else if (rigCaps.model == model7850)
-                    value = getCalibratedValue(rigState->sMeter, IC7850_STR_CAL);
+                    value = getCalibratedValue(rigState->sMeter(), IC7850_STR_CAL);
                 else
-                    value = getCalibratedValue(rigState->sMeter, IC7300_STR_CAL);
+                    value = getCalibratedValue(rigState->sMeter(), IC7300_STR_CAL);
                 //qInfo(logRigCtlD()) << "Calibration IN:" << rigState->sMeter << "OUT" << value;
                 resp.append(QString("%1").arg(value));
             }
             else if (command[1] == "AF") {
-                resp.append(QString("%1").arg((float)rigState->afGain / 255.0));
+                resp.append(QString("%1").arg((float)rigState->afGain() / 255.0));
             }
             else if (command[1] == "RF") {
-                resp.append(QString("%1").arg((float)rigState->rfGain / 255.0));
+                resp.append(QString("%1").arg((float)rigState->rfGain() / 255.0));
             }
             else if (command[1] == "SQL") {
-                resp.append(QString("%1").arg((float)rigState->squelch / 255.0));
+                resp.append(QString("%1").arg((float)rigState->squelch() / 255.0));
             }
             else if (command[1] == "COMP") {
-                resp.append(QString("%1").arg((float)rigState->compLevel / 255.0));
+                resp.append(QString("%1").arg((float)rigState->compLevel() / 255.0));
             }
             else if (command[1] == "MICGAIN") {
-                resp.append(QString("%1").arg((float)rigState->micGain / 255.0));
+                resp.append(QString("%1").arg((float)rigState->micGain() / 255.0));
             }
             else if (command[1] == "MON") {
-                resp.append(QString("%1").arg((float)rigState->monitorLevel / 255.0));
+                resp.append(QString("%1").arg((float)rigState->monitorLevel() / 255.0));
             }
             else if (command[1] == "VOXGAIN") {
-                resp.append(QString("%1").arg((float)rigState->voxGain / 255.0));
+                resp.append(QString("%1").arg((float)rigState->voxGain() / 255.0));
             }
             else if (command[1] == "ANTIVOX") {
-                resp.append(QString("%1").arg((float)rigState->antiVoxGain / 255.0));
+                resp.append(QString("%1").arg((float)rigState->antiVoxGain() / 255.0));
             }
             else if (command[1] == "RFPOWER") {
-                resp.append(QString("%1").arg((float)rigState->txPower / 255.0));
+                resp.append(QString("%1").arg((float)rigState->txPower() / 255.0));
             }
             else if (command[1] == "PREAMP") {
-                resp.append(QString("%1").arg((float)rigState->preamp / 255.0));
+                resp.append(QString("%1").arg(rigState->preamp()*10));
             }
             else if (command[1] == "ATT") {
-                resp.append(QString("%1").arg((float)rigState->attenuator / 255.0));
+                resp.append(QString("%1").arg(rigState->attenuator()));
             }
             else {
                 resp.append(QString("%1").arg(value));
@@ -677,55 +666,49 @@ void rigCtlClient::socketReadyRead()
             setCommand = true;
             if (command[1] == "AF") {
                 value = command[2].toFloat() * 255;
-                emit parent->setAfGain(value);
-                rigState->afGain = value;
+                rigState->afGain(value,AFGAIN);
             }
             else if (command[1] == "RF") {
                 value = command[2].toFloat() * 255;
-                emit parent->setRfGain(value);
-                rigState->rfGain = value;
+                rigState->rfGain(value,RFGAIN);
             }
             else if (command[1] == "SQL") {
                 value = command[2].toFloat() * 255;
-                emit parent->setSql(value);
-                rigState->squelch = value;
+                rigState->squelch(value,SQUELCH);
             }
             else if (command[1] == "COMP") {
                 value = command[2].toFloat() * 255;
-                emit parent->setCompLevel(value);
-                rigState->compLevel = value;
+                rigState->compLevel(value,COMPLEVEL);
             }
             else if (command[1] == "MICGAIN") {
                 value = command[2].toFloat() * 255;
-                emit parent->setMicGain(value);
-                rigState->micGain = value;
+                rigState->micGain(value,MICGAIN);
             }
             else if (command[1] == "MON") {
                 value = command[2].toFloat() * 255;
-                emit parent->setMonitorLevel(value);
-                rigState->monitorLevel = value;
+                rigState->monitorLevel(value,MONITORLEVEL);
             }
             else if (command[1] == "VOXGAIN") {
                 value = command[2].toFloat() * 255;
-                emit parent->setVoxGain(value);
-                rigState->voxGain = value;
+                rigState->voxGain(value,VOXGAIN);
             }
             else if (command[1] == "ANTIVOX") {
                 value = command[2].toFloat() * 255;
-                emit parent->setAntiVoxGain(value);
-                rigState->antiVoxGain = value;
+                rigState->antiVoxGain(value,ANTIVOXGAIN);
             }
             else if (command[1] == "ATT") {
                 value = command[2].toFloat();
-                emit parent->setAttenuator(value);
-                rigState->attenuator = value;
+                rigState->attenuator(value,ATTENUATOR);
             }
             else if (command[1] == "PREAMP") {
-                value = command[2].toFloat()/10;
-                emit parent->setPreamp(value);
-                rigState->preamp = value;
+                value = command[2].toFloat() / 10;
+                rigState->preamp(value, PREAMP);
             }
-            
+            else if (command[1] == "AGC") {
+                value = command[2].toInt();;
+                rigState->agc(value, AGC);
+            }
+
             qInfo(logRigCtlD()) << "Setting:" << command[1] << command[2] << value;
 
         }
@@ -739,265 +722,266 @@ void rigCtlClient::socketReadyRead()
             
             if (command[1] == "FAGC")
             {               
-                result=rigState->fagcFunc;
+                result=rigState->fagcFunc();
             }
             else if (command[1] == "NB")
             {
-                result=rigState->nbFunc;
+                result = rigState->nbFunc();
             }
             else if (command[1] == "COMP")
             {
-                result=rigState->compFunc;
+                result=rigState->compFunc();
             }
             else if (command[1] == "VOX")
             {
-                result = rigState->voxFunc;
+                result = rigState->voxFunc();
             }
             else if (command[1] == "TONE")
             {
-                result = rigState->toneFunc;
+                result = rigState->toneFunc();
             }
             else if (command[1] == "TSQL")
             {
-                result = rigState->tsqlFunc;
+                result = rigState->tsqlFunc();
             }
             else if (command[1] == "SBKIN")
             {
-                result = rigState->sbkinFunc;
+                result = rigState->sbkinFunc();
             }
             else if (command[1] == "FBKIN")
             {
-                result = rigState->fbkinFunc;
+                result = rigState->fbkinFunc();
             }
             else if (command[1] == "ANF")
             {
-                result = rigState->anfFunc;
+                result = rigState->anfFunc();
             }
             else if (command[1] == "NR")
             {
-                result = rigState->nrFunc;
+                result = rigState->nrFunc();
             }
             else if (command[1] == "AIP")
             {
-                result = rigState->aipFunc;
+                result = rigState->aipFunc();
             }
             else if (command[1] == "APF")
             {
-                result = rigState->apfFunc;
+                result = rigState->apfFunc();
             }
             else if (command[1] == "MON")
             {
-                result = rigState->monFunc;
+                result = rigState->monFunc();
             }
             else if (command[1] == "MN")
             {
-                result = rigState->mnFunc;
+                result = rigState->mnFunc();
             }
             else if (command[1] == "RF")
             {
-                result = rigState->rfFunc;
+                result = rigState->rfFunc();
             }
             else if (command[1] == "ARO")
             {
-                result = rigState->aroFunc;
+                result = rigState->aroFunc();
             }
             else if (command[1] == "MUTE")
             {
-                result = rigState->muteFunc;
+                result = rigState->muteFunc();
             }
             else if (command[1] == "VSC")
             {
-                result = rigState->vscFunc;
+                result = rigState->vscFunc();
             }
             else if (command[1] == "REV")
             {
-                result = rigState->revFunc;
+                result = rigState->revFunc();
             }
             else if (command[1] == "SQL")
             {
-                result = rigState->sqlFunc;
+                result = rigState->sqlFunc();
             }
             else if (command[1] == "ABM")
             {
-                result = rigState->abmFunc;
+                result = rigState->abmFunc();
             }
             else if (command[1] == "BC")
             {
-                result = rigState->bcFunc;
+                result = rigState->bcFunc();
             }
             else if (command[1] == "MBC")
             {
-                result = rigState->mbcFunc;
+                result = rigState->mbcFunc();
             }
             else if (command[1] == "RIT")
             {
-                result = rigState->ritFunc;
+                result = rigState->ritFunc();
             }
             else if (command[1] == "AFC")
             {
-                result = rigState->afcFunc;
+                result = rigState->afcFunc();
             }
             else if (command[1] == "SATMODE")
             {
-                result = rigState->satmodeFunc;
+                result = rigState->satmodeFunc();
             }
             else if (command[1] == "SCOPE")
             {
-                result = rigState->scopeFunc;
+                result = rigState->scopeFunc();
             }
             else if (command[1] == "RESUME")
             {
-                result = rigState->resumeFunc;
+                result = rigState->resumeFunc();
             }
             else if (command[1] == "TBURST")
             {
-                result = rigState->tburstFunc;
+                result = rigState->tburstFunc();
             }
             else if (command[1] == "TUNER")
             {
-                result = rigState->tunerFunc;
+                result = rigState->tunerFunc();
             }
             else if (command[1] == "LOCK")
             {
-                result = rigState->lockFunc;
+                result = rigState->lockFunc();
             }
             else {
                 qInfo(logRigCtlD()) << "Unimplemented func:" << command[0] << command[1];
             }
-
             resp.append(QString("%1").arg(result));
             response.append(resp);
         }
         else if (command.length() >2 && (command[0] == "U" || command[0] == "set_func"))
         {
             setCommand = true;
+            
             if (command[1] == "FAGC")
             {
-                rigState->fagcFunc = (bool)command[2].toInt();
+                rigState->fagcFunc((bool)command[2].toInt(),FAGCFUNC);
             }
             else if (command[1] == "NB")
             {
-                rigState->nbFunc = (bool)command[2].toInt();
+                rigState->nbFunc((bool)command[2].toInt(),NBFUNC);
             }
             else if (command[1] == "COMP")
             {
-                rigState->compFunc = (bool)command[2].toInt();
+                rigState->compFunc((bool)command[2].toInt(),COMPFUNC);
             }
             else if (command[1] == "VOX")
             {
-                rigState->voxFunc = (bool)command[2].toInt();
+                rigState->voxFunc((bool)command[2].toInt(),VOXFUNC);
             }
             else if (command[1] == "TONE")
             {
-                rigState->toneFunc = (bool)command[2].toInt();
+                rigState->toneFunc((bool)command[2].toInt(),TONEFUNC);
             }
             else if (command[1] == "TSQL")
             {
-                rigState->tsqlFunc = (bool)command[2].toInt();
+                rigState->tsqlFunc((bool)command[2].toInt(),TSQLFUNC);
             }
             else if (command[1] == "SBKIN")
             {
-                rigState->sbkinFunc = (bool)command[2].toInt();
+                rigState->sbkinFunc((bool)command[2].toInt(),SBKINFUNC);
             }
             else if (command[1] == "FBKIN")
             {
-                rigState->fbkinFunc = (bool)command[2].toInt();
+                rigState->fbkinFunc((bool)command[2].toInt(),FBKINFUNC);
             }
             else if (command[1] == "ANF")
             {
-                rigState->anfFunc = (bool)command[2].toInt();
+                rigState->anfFunc((bool)command[2].toInt(),ANFFUNC);
             }
             else if (command[1] == "NR")
             {
-                rigState->nrFunc = (bool)command[2].toInt();
+                rigState->nrFunc((bool)command[2].toInt(),NRFUNC);
             }
             else if (command[1] == "AIP")
             {
-                rigState->aipFunc = (bool)command[2].toInt();
+                rigState->aipFunc((bool)command[2].toInt(),AIPFUNC);
             }
             else if (command[1] == "APF")
             {
-                rigState->apfFunc = (bool)command[2].toInt();
+                rigState->apfFunc((bool)command[2].toInt(),APFFUNC);
             }
             else if (command[1] == "MON")
             {
-                rigState->monFunc = (bool)command[2].toInt();
+                rigState->monFunc((bool)command[2].toInt(),MONFUNC);
             }
             else if (command[1] == "MN")
             {
-                rigState->mnFunc = (bool)command[2].toInt();
+                rigState->mnFunc((bool)command[2].toInt(),MNFUNC);
             }
             else if (command[1] == "RF")
             {
-                rigState->rfFunc = (bool)command[2].toInt();
+                rigState->rfFunc((bool)command[2].toInt(),MONFUNC);
             }
             else if (command[1] == "ARO")
             {
-                rigState->aroFunc = (bool)command[2].toInt();
+                rigState->aroFunc((bool)command[2].toInt(),AROFUNC);
             }
             else if (command[1] == "MUTE")
             {
-                rigState->muteFunc = (bool)command[2].toInt();
+                rigState->muteFunc((bool)command[2].toInt(),MUTEFUNC);
             }
             else if (command[1] == "VSC")
             {
-                rigState->vscFunc = (bool)command[2].toInt();
+                rigState->vscFunc((bool)command[2].toInt(),VSCFUNC);
             }
             else if (command[1] == "REV")
             {
-                rigState->revFunc = (bool)command[2].toInt();
+                rigState->revFunc((bool)command[2].toInt(),REVFUNC);
             }
             else if (command[1] == "SQL")
             {
-                rigState->sqlFunc = (bool)command[2].toInt();
+                rigState->sqlFunc((bool)command[2].toInt(),SQLFUNC);
             }
             else if (command[1] == "ABM")
             {
-                rigState->abmFunc = (bool)command[2].toInt();
+                rigState->abmFunc((bool)command[2].toInt(),ABMFUNC);
             }
             else if (command[1] == "BC")
             {
-                rigState->bcFunc = (bool)command[2].toInt();
+                rigState->bcFunc((bool)command[2].toInt(),BCFUNC);
             }
             else if (command[1] == "MBC")
             {
-                rigState->mbcFunc = (bool)command[2].toInt();
+                rigState->mbcFunc((bool)command[2].toInt(),MBCFUNC);
             }
             else if (command[1] == "RIT")
             {
-                rigState->ritFunc = (bool)command[2].toInt();
+                rigState->ritFunc((bool)command[2].toInt(),RITFUNC);
             }
             else if (command[1] == "AFC")
             {
-                rigState->afcFunc = (bool)command[2].toInt();
+                rigState->afcFunc((bool)command[2].toInt(),AFCFUNC);
             }
             else if (command[1] == "SATMODE")
             {
-                rigState->satmodeFunc = (bool)command[2].toInt();
+                rigState->satmodeFunc((bool)command[2].toInt(),SATMODEFUNC);
             }
             else if (command[1] == "SCOPE")
             {
-                rigState->scopeFunc = (bool)command[2].toInt();
+                rigState->scopeFunc((bool)command[2].toInt(),SCOPEFUNC);
             }
             else if (command[1] == "RESUME")
             {
-                rigState->resumeFunc = (bool)command[2].toInt();
+                rigState->resumeFunc((bool)command[2].toInt(),RESUMEFUNC);
             }
             else if (command[1] == "TBURST")
             {
-                rigState->tburstFunc = (bool)command[2].toInt();
+                rigState->tburstFunc((bool)command[2].toInt(),TBURSTFUNC);
             }
             else if (command[1] == "TUNER")
             {
-                rigState->tunerFunc = (bool)command[2].toInt();
+                rigState->tunerFunc((bool)command[2].toInt(),TUNERFUNC);
             }
             else if (command[1] == "LOCK")
             {
-                rigState->lockFunc = (bool)command[2].toInt();
+                rigState->lockFunc((bool)command[2].toInt(),LOCKFUNC);
             }
             else {
                 qInfo(logRigCtlD()) << "Unimplemented func:" << command[0] << command[1] << command[2];
             }
+            
             qInfo(logRigCtlD()) << "Setting:" << command[1] << command[2];
         }
         else if (command.length() > 1 && (command[0] == 0x88 || command[0] == "get_powerstat"))
@@ -1034,6 +1018,11 @@ void rigCtlClient::socketReadyRead()
                 sendData(QString("%1: %2 %3 %4%5").arg(command[0]).arg(command[1]).arg(command[2]).arg(command[3]).arg(sep));
         }
 
+        if (setCommand)
+        {
+            emit parent->stateUpdated();
+        }
+
         if (setCommand || responseCode != 0 || longReply) {
             if (responseCode == 0) {
                 response.append(QString("RPRT 0"));
@@ -1056,6 +1045,7 @@ void rigCtlClient::socketReadyRead()
         commandBuffer.clear();
         sep = " ";
         num = 0;
+
     }
 }
 
@@ -1073,7 +1063,7 @@ void rigCtlClient::closeSocket()
 
 void rigCtlClient::sendData(QString data)
 {
-    qDebug(logRigCtlD()) << "Sending:" << data;
+    //qDebug(logRigCtlD()) << "Sending:" << data;
     if (socket != Q_NULLPTR && socket->isValid() && socket->isOpen())
     {
         socket->write(data.toLatin1());
@@ -1380,6 +1370,28 @@ QString rigCtlClient::getAntName(unsigned char ant)
     return ret;
 }
 
+unsigned char rigCtlClient::antFromName(QString name) {
+    unsigned char ret;
+
+    if (name == "ANT1")
+        ret = 0;
+    else if (name == "ANT2")
+        ret = 1;
+    else if (name == "ANT3")
+        ret = 2;
+    else if (name == "ANT4")
+        ret = 3;
+    else if (name == "ANT5")
+        ret = 4;
+    else if (name == "ANT_UNKNOWN")
+        ret = 30;
+    else if (name == "ANT_CURR")
+        ret = 31;
+    else  
+        ret = 99;
+    return ret;
+}
+
 int rigCtlClient::getCalibratedValue(unsigned char meter,cal_table_t cal) {
     
     int interp;
diff --git a/rigctld.h b/rigctld.h
index 130ae5e..1132abf 100644
--- a/rigctld.h
+++ b/rigctld.h
@@ -19,6 +19,7 @@
 #include <typeindex>
 
 #include "rigcommander.h"
+#include "rigstate.h"
 
 #define CONSTANT_64BIT_FLAG(BIT) (1ull << (BIT))
 
@@ -343,7 +344,7 @@ signals:
     void setVFO(unsigned char vfo);
     void setSplit(unsigned char split);
     void setDuplexMode(duplexMode dm);
-
+    void stateUpdated();
     // Power
     void sendPowerOn();
     void sendPowerOff();
@@ -368,11 +369,11 @@ signals:
 public slots:
     virtual void incomingConnection(qintptr socketDescriptor);
     void receiveRigCaps(rigCapabilities caps);
-    void receiveStateInfo(rigStateStruct* state);
+    void receiveStateInfo(rigstate* state);
 //    void receiveFrequency(freqt freq);
 
 private: 
-    rigStateStruct* rigState = Q_NULLPTR;
+    rigstate* rigState = Q_NULLPTR;
 };
 
 
@@ -382,7 +383,7 @@ class rigCtlClient : public QObject
 
 public:
 
-    explicit rigCtlClient(int socket, rigCapabilities caps, rigStateStruct *state, rigCtlD* parent = Q_NULLPTR);
+    explicit rigCtlClient(int socket, rigCapabilities caps, rigstate *state, rigCtlD* parent = Q_NULLPTR);
     int getSocketId();
 
 
@@ -399,7 +400,7 @@ protected:
 
 private:
     rigCapabilities rigCaps;
-    rigStateStruct* rigState = Q_NULLPTR;
+    rigstate* rigState = Q_NULLPTR;
     rigCtlD* parent;
     QString getMode(unsigned char mode, bool datamode);
     unsigned char getMode(QString modeString);
@@ -408,6 +409,7 @@ private:
     unsigned char getAntennas();
     quint64 getRadioModes();
     QString getAntName(unsigned char ant);
+    unsigned char antFromName(QString name);
     int getCalibratedValue(unsigned char meter,cal_table_t cal);
 };
 
diff --git a/rigstate.h b/rigstate.h
new file mode 100644
index 0000000..7aef7d6
--- /dev/null
+++ b/rigstate.h
@@ -0,0 +1,264 @@
+#ifndef RIGSTATE_H
+#define RIGSTATE_H
+
+#include <QObject>
+#include <QMutex>
+
+#include "rigcommander.h"
+
+// Meters at the end as they are ALWAYS updated from the rig!
+enum stateTypes { NONE, VFOAFREQ, VFOBFREQ, CURRENTVFO, PTT, MODE, FILTER, DUPLEX, DATAMODE, ANTENNA, RXANTENNA, CTCSS, TSQL, DTCS, CSQL,
+                  PREAMP, AGC, ATTENUATOR, MODINPUT, AFGAIN, RFGAIN, SQUELCH, TXPOWER, MICGAIN, COMPLEVEL, MONITORLEVEL, VOXGAIN, ANTIVOXGAIN,
+                  FAGCFUNC, NBFUNC, COMPFUNC, VOXFUNC, TONEFUNC, TSQLFUNC, SBKINFUNC, FBKINFUNC, ANFFUNC, NRFUNC, AIPFUNC, APFFUNC, MONFUNC, MNFUNC,RFFUNC,
+                  AROFUNC, MUTEFUNC, VSCFUNC, REVFUNC, SQLFUNC, ABMFUNC, BCFUNC, MBCFUNC, RITFUNC, AFCFUNC, SATMODEFUNC, SCOPEFUNC,
+                  RESUMEFUNC, TBURSTFUNC, TUNERFUNC, LOCKFUNC, SMETER, POWERMETER, SWRMETER, ALCMETER, COMPMETER, VOLTAGEMETER, CURRENTMETER };
+
+
+class rigstate
+{
+
+public:
+
+    void lock() { _mutex.lock(); return; }
+    void unlock() { _mutex.unlock(); return; }
+
+    quint64 updated() { return _updated; }
+    void updated(int update) { _mutex.lock(); _updated |= 1ULL << update; _mutex.unlock(); }
+
+    quint64 vfoAFreq() { return _vfoAFreq; }
+    void vfoAFreq(quint64 vfoAFreq, int update) { _mutex.lock();  _vfoAFreq = vfoAFreq; _updated |= 1ULL << update; _mutex.unlock(); }
+
+    quint64 vfoBFreq() { return _vfoBFreq; }
+    void vfoBFreq(quint64 vfoBFreq, int update) { _mutex.lock();  _vfoBFreq = vfoBFreq; _updated |= 1ULL << update; _mutex.unlock(); }
+
+    unsigned char currentVfo() { return _currentVfo; }
+    void currentVfo(unsigned char currentVfo, int update) { _mutex.lock(); _currentVfo = currentVfo; _updated |= 1ULL << update; _mutex.unlock(); }
+
+    bool ptt() { return _ptt; }
+    void ptt(bool ptt, int update) { _mutex.lock(); _ptt = ptt; _updated |= 1ULL << update; _mutex.unlock(); }
+
+    unsigned char mode() { return _mode; }
+    void mode(unsigned char mode, int update) { _mutex.lock(); _mode = mode; _updated |= 1ULL << update; _mutex.unlock(); }
+
+    unsigned char filter() { return _filter; }
+    void filter(unsigned char filter,  int update) { _mutex.lock(); _filter = filter; _updated |= 1ULL << update; _mutex.unlock();}
+
+    duplexMode duplex() { return _duplex; }
+    void duplex(duplexMode duplex,  int update) { _mutex.lock(); _duplex = duplex; _updated |= 1ULL << update; _mutex.unlock();}
+
+    bool datamode() { return _datamode; }
+    void datamode(bool datamode,  int update) { _mutex.lock(); _datamode = datamode; _updated |= 1ULL << update; _mutex.unlock();}
+
+    unsigned char antenna() { return _antenna; }
+    void antenna(unsigned char antenna,  int update) { _mutex.lock(); _antenna = antenna; _updated |= 1ULL << update; _mutex.unlock();}
+
+    bool rxAntenna() { return _rxAntenna; }
+    void rxAntenna(bool rxAntenna, int update) { _mutex.lock(); _rxAntenna = rxAntenna; _updated |= 1ULL << update; _mutex.unlock(); }
+    quint16 ctcss() { return _ctcss; }
+    void ctcss(quint16 ctcss,  int update) { _mutex.lock(); _ctcss = ctcss; _updated |= 1ULL << update; _mutex.unlock(); }
+    quint16 tsql() { return _tsql; }
+    void tsql(quint16 tsql,  int update) { _mutex.lock(); _tsql = tsql; _updated |= 1ULL << update; _mutex.unlock(); }
+    quint16 dtcs() { return _dtcs; }
+    void dtcs(quint16 dtcs,  int update) { _mutex.lock(); _dtcs = dtcs; _updated |= 1ULL << update; _mutex.unlock(); }
+    quint16 csql() { return _csql; }
+    void csql(quint16 csql,  int update) { _mutex.lock(); _csql = csql; _updated |= 1ULL << update; _mutex.unlock(); }
+
+    unsigned char preamp() { return _preamp; }
+    void preamp(unsigned char preamp, int update) { _mutex.lock(); _preamp = preamp; _updated |= 1ULL << update; _mutex.unlock(); }
+    unsigned char agc() { return _agc; }
+    void agc(unsigned char agc, int update) { _mutex.lock(); _agc = agc; _updated |= 1ULL << update; _mutex.unlock(); }
+    unsigned char attenuator() { return _attenuator; }
+    void attenuator(unsigned char attenuator, int update) { _mutex.lock(); _attenuator = attenuator; _updated |= 1ULL << update; _mutex.unlock(); }
+    unsigned char modInput() { return _modInput; }
+    void modInput(unsigned char modInput, int update) { _mutex.lock(); _modInput = modInput; _updated |= 1ULL << update; _mutex.unlock(); }
+    unsigned char afGain() { return _afGain; }
+    void afGain(unsigned char afGain, int update) { _mutex.lock(); _afGain = afGain; _updated |= 1ULL << update; _mutex.unlock(); }
+    unsigned char rfGain() { return _rfGain; }
+    void rfGain(unsigned char rfGain, int update) { _mutex.lock(); _rfGain = rfGain; _updated |= 1ULL << update; _mutex.unlock(); }
+    unsigned char squelch() { return _squelch; }
+    void squelch(unsigned char squelch, int update) { _mutex.lock(); _squelch = squelch; _updated |= 1ULL << update; _mutex.unlock(); }
+    unsigned char txPower() { return _txPower; }
+    void txPower(unsigned char txPower, int update) { _mutex.lock(); _txPower = txPower; _updated |= 1ULL << update; _mutex.unlock(); }
+    unsigned char micGain() { return _micGain; }
+    void micGain(unsigned char micGain, int update) { _mutex.lock(); _micGain = micGain; _updated |= 1ULL << update; _mutex.unlock(); }
+    unsigned char compLevel() { return _compLevel; }
+    void compLevel(unsigned char compLevel, int update) { _mutex.lock(); _compLevel = compLevel; _updated |= 1ULL << update; _mutex.unlock(); }
+    unsigned char monitorLevel() { return _monitorLevel; }
+    void monitorLevel(unsigned char monitorLevel, int update) { _mutex.lock(); _monitorLevel = monitorLevel; _updated |= 1ULL << update; _mutex.unlock(); }
+    unsigned char voxGain() { return _voxGain; }
+    void voxGain(unsigned char voxGain, int update) { _mutex.lock(); _voxGain = voxGain; _updated |= 1ULL << update; _mutex.unlock(); }
+    unsigned char antiVoxGain() { return _antiVoxGain; }
+    void antiVoxGain(unsigned char antiVoxGain, int update) { _mutex.lock(); _antiVoxGain = antiVoxGain; _updated |= 1ULL << update; _mutex.unlock(); }
+    unsigned char nbLevel() { return _nbLevel; }
+    void nbLevel(unsigned char nbLevel, int update) { _mutex.lock(); _nbLevel = nbLevel; _updated |= 1ULL << update; _mutex.unlock(); }
+    unsigned char nbDepth() { return _nbDepth; }
+    void nbDepth(unsigned char nbDepth, int update) { _mutex.lock(); _nbDepth = nbDepth; _updated |= 1ULL << update; _mutex.unlock(); }
+    unsigned char nbWidth() { return _nbWidth; }
+    void nbWidth(unsigned char nbWidth, int update) { _mutex.lock(); _nbWidth = nbWidth; _updated |= 1ULL << update; _mutex.unlock(); }
+    unsigned char nrLevel() { return _nrLevel; }
+    void nrLevel(unsigned char nrLevel, int update) { _mutex.lock(); _nrLevel = nrLevel; _updated |= 1ULL << update; _mutex.unlock(); }
+
+    unsigned char sMeter() { return _sMeter; }
+    void sMeter(unsigned char sMeter, int update) { _mutex.lock(); _sMeter = sMeter; _updated |= 1ULL << update; _mutex.unlock(); }
+    unsigned char powerMeter() { return _powerMeter; }
+    void powerMeter(unsigned char powerMeter, int update) { _mutex.lock(); _powerMeter = powerMeter; _updated |= 1ULL << update; _mutex.unlock(); }
+    unsigned char swrMeter() { return _swrMeter; }
+    void swrMeter(unsigned char swrMeter, int update) { _mutex.lock(); _swrMeter = swrMeter; _updated |= 1ULL << update; _mutex.unlock(); }
+    unsigned char alcMeter() { return _alcMeter; }
+    void alcMeter(unsigned char alcMeter, int update) { _mutex.lock(); _alcMeter = alcMeter; _updated |= 1ULL << update; _mutex.unlock(); }
+    unsigned char compMeter() { return _compMeter; }
+    void compMeter(unsigned char compMeter, int update) { _mutex.lock(); _compMeter = compMeter; _updated |= 1ULL << update; _mutex.unlock(); }
+    unsigned char voltageMeter() { return _voltageMeter; }
+    void voltageMeter(unsigned char voltageMeter, int update) { _mutex.lock(); _voltageMeter = voltageMeter; _updated |= 1ULL << update; _mutex.unlock(); }
+    unsigned char currentMeter() { return _currentMeter; }
+    void currentMeter(unsigned char currentMeter, int update) { _mutex.lock(); _currentMeter = currentMeter; _updated |= 1ULL << update; _mutex.unlock(); }
+
+    /*FAGCFUNC, NBFUNC, COMPFUNC, VOXFUNC, TONEFUNC, TSQLFUNC, SBKINFUNC, FBKINFUNC, ANFFUNC, NRFUNC, AIPFUNC, APFFUNC, MONFUNC, MNFUNC,RFFUNC,
+    */
+    bool fagcFunc() { return _fagcFunc; }
+    void fagcFunc(bool fagcFunc, int update) { _mutex.lock(); _fagcFunc = fagcFunc; _updated |= 1ULL << update; _mutex.unlock(); }
+    bool nbFunc() { return _nbFunc; }
+    void nbFunc(bool nbFunc, int update) { _mutex.lock(); _nbFunc = nbFunc; _updated |= 1ULL << update; _mutex.unlock(); }
+    bool compFunc() { return _compFunc; }
+    void compFunc(bool compFunc, int update) { _mutex.lock(); _compFunc = compFunc; _updated |= 1ULL << update; _mutex.unlock(); }
+    bool voxFunc() { return _voxFunc; }
+    void voxFunc(bool voxFunc, int update) { _mutex.lock(); _voxFunc = voxFunc; _updated |= 1ULL << update; _mutex.unlock(); }
+    bool toneFunc() { return _toneFunc; }
+    void toneFunc(bool toneFunc, int update) { _mutex.lock(); _toneFunc = toneFunc; _updated |= 1ULL << update; _mutex.unlock(); }
+    bool tsqlFunc() { return _tsqlFunc; }
+    void tsqlFunc(bool tsqlFunc, int update) { _mutex.lock(); _tsqlFunc = tsqlFunc; _updated |= 1ULL << update; _mutex.unlock(); }
+    bool sbkinFunc() { return _sbkinFunc; }
+    void sbkinFunc(bool sbkinFunc, int update) { _mutex.lock(); _sbkinFunc = sbkinFunc; _updated |= 1ULL << update; _mutex.unlock(); }
+    bool fbkinFunc() { return _fbkinFunc; }
+    void fbkinFunc(bool fbkinFunc, int update) { _mutex.lock(); _fbkinFunc = fbkinFunc; _updated |= 1ULL << update; _mutex.unlock(); }
+    bool anfFunc() { return _anfFunc; }
+    void anfFunc(bool anfFunc, int update) { _mutex.lock(); _anfFunc = anfFunc; _updated |= 1ULL << update; _mutex.unlock(); }
+    bool nrFunc() { return _nrFunc; }
+    void nrFunc(bool nrFunc, int update) { _mutex.lock(); _nrFunc = nrFunc; _updated |= 1ULL << update; _mutex.unlock(); }
+    bool aipFunc() { return _aipFunc; }
+    void aipFunc(bool aipFunc, int update) { _mutex.lock(); _aipFunc = aipFunc; _updated |= 1ULL << update; _mutex.unlock(); }
+    bool apfFunc() { return _apfFunc; }
+    void apfFunc(bool apfFunc, int update) { _mutex.lock(); _apfFunc = apfFunc; _updated |= 1ULL << update; _mutex.unlock(); }
+    bool monFunc() { return _monFunc; }
+    void monFunc(bool monFunc, int update) { _mutex.lock(); _monFunc = monFunc; _updated |= 1ULL << update; _mutex.unlock(); }
+    bool mnFunc() { return _mnFunc; }
+    void mnFunc(bool mnFunc, int update) { _mutex.lock(); _mnFunc = mnFunc; _updated |= 1ULL << update; _mutex.unlock(); }
+    bool rfFunc() { return _rfFunc; }
+    void rfFunc(bool rfFunc, int update) { _mutex.lock(); _rfFunc = rfFunc; _updated |= 1ULL << update; _mutex.unlock(); }
+
+    /* AROFUNC, MUTEFUNC, VSCFUNC, REVFUNC, SQLFUNC, ABMFUNC, BCFUNC, MBCFUNC, RITFUNC, AFCFUNC, SATMODEFUNC, SCOPEFUNC,
+        RESUMEFUNC, TBURSTFUNC, TUNERFUNC}; */
+    bool aroFunc() { return _aroFunc; }
+    void aroFunc(bool aroFunc, int update) { _mutex.lock(); _aroFunc = aroFunc; _updated |= 1ULL << update; _mutex.unlock(); }
+    bool muteFunc() { return _muteFunc; }
+    void muteFunc(bool muteFunc, int update) { _mutex.lock(); _muteFunc = muteFunc; _updated |= 1ULL << update; _mutex.unlock(); }
+    bool vscFunc() { return _vscFunc; }
+    void vscFunc(bool vscFunc, int update) { _mutex.lock(); _vscFunc = vscFunc; _updated |= 1ULL << update; _mutex.unlock(); }
+    bool revFunc() { return _revFunc; }
+    void revFunc(bool revFunc, int update) { _mutex.lock(); _revFunc = revFunc; _updated |= 1ULL << update; _mutex.unlock(); }
+    bool sqlFunc() { return _sqlFunc; }
+    void sqlFunc(bool sqlFunc, int update) { _mutex.lock(); _sqlFunc = sqlFunc; _updated |= 1ULL << update; _mutex.unlock(); }
+    bool abmFunc() { return _abmFunc; }
+    void abmFunc(bool abmFunc, int update) { _mutex.lock(); _abmFunc = abmFunc; _updated |= 1ULL << update; _mutex.unlock(); }
+    bool bcFunc() { return _bcFunc; }
+    void bcFunc(bool bcFunc, int update) { _mutex.lock(); _bcFunc = bcFunc; _updated |= 1ULL << update; _mutex.unlock(); }
+    bool mbcFunc() { return _mbcFunc; }
+    void mbcFunc(bool mbcFunc, int update) { _mutex.lock(); _mbcFunc = mbcFunc; _updated |= 1ULL << update; _mutex.unlock(); }
+    bool ritFunc() { return _ritFunc; }
+    void ritFunc(bool ritFunc, int update) { _mutex.lock(); _ritFunc = ritFunc; _updated |= 1ULL << update; _mutex.unlock(); }
+    bool afcFunc() { return _afcFunc; }
+    void afcFunc(bool afcFunc, int update) { _mutex.lock(); _afcFunc = afcFunc; _updated |= 1ULL << update; _mutex.unlock(); }
+    bool satmodeFunc() { return _satmodeFunc; }
+    void satmodeFunc(bool satmodeFunc, int update) { _mutex.lock(); _satmodeFunc = satmodeFunc; _updated |= 1ULL << update; _mutex.unlock(); }
+    bool scopeFunc() { return _scopeFunc; }
+    void scopeFunc(bool scopeFunc, int update) { _mutex.lock(); _scopeFunc = scopeFunc; _updated |= 1ULL << update; _mutex.unlock(); }
+    bool resumeFunc() { return _resumeFunc; }
+    void resumeFunc(bool resumeFunc, int update) { _mutex.lock(); _resumeFunc = resumeFunc; _updated |= 1ULL << update; _mutex.unlock(); }
+    bool tburstFunc() { return _tburstFunc; }
+    void tburstFunc(bool tburstFunc, int update) { _mutex.lock(); _tburstFunc = tburstFunc; _updated |= 1ULL << update; _mutex.unlock(); }
+    bool tunerFunc() { return _tunerFunc; }
+    void tunerFunc(bool tunerFunc, int update) { _mutex.lock(); _tunerFunc = tunerFunc; _updated |= 1ULL << update; _mutex.unlock(); }
+    bool lockFunc() { return _lockFunc; }
+    void lockFunc(bool lockFunc, int update) { _mutex.lock(); _lockFunc = lockFunc; _updated |= 1ULL << update; _mutex.unlock(); }
+
+
+private:
+    QMutex _mutex;
+    quint64 _updated=0;
+    quint64 _vfoAFreq=0;
+    quint64 _vfoBFreq=0;
+    unsigned char _currentVfo=0;
+    bool _ptt=0;
+    unsigned char _mode=0;
+    unsigned char _filter=0;
+    duplexMode _duplex;
+    bool _datamode=0;
+    unsigned char _antenna=0;
+    bool _rxAntenna=0;
+    // Tones
+    quint16 _ctcss;
+    quint16 _tsql;
+    quint16 _dtcs;
+    quint16 _csql;
+    // Levels
+    unsigned char _preamp;
+    unsigned char _agc;
+    unsigned char _attenuator;
+    unsigned char _modInput;
+    unsigned char _afGain;
+    unsigned char _rfGain;
+    unsigned char _squelch;
+    unsigned char _txPower;
+    unsigned char _micGain;
+    unsigned char _compLevel;
+    unsigned char _monitorLevel;
+    unsigned char _voxGain;
+    unsigned char _antiVoxGain;
+    unsigned char _nrLevel;
+    unsigned char _nbLevel;
+    unsigned char _nbDepth;
+    unsigned char _nbWidth;
+    // Meters
+    unsigned char _sMeter;
+    unsigned char _powerMeter;
+    unsigned char _swrMeter;
+    unsigned char _alcMeter;
+    unsigned char _compMeter;
+    unsigned char _voltageMeter;
+    unsigned char _currentMeter;
+    // Functions
+    bool _fagcFunc = false;
+    bool _nbFunc = false;
+    bool _compFunc = false;
+    bool _voxFunc = false;
+    bool _toneFunc = false;
+    bool _tsqlFunc = false;
+    bool _sbkinFunc = false;
+    bool _fbkinFunc = false;
+    bool _anfFunc = false;
+    bool _nrFunc = false;
+    bool _aipFunc = false;
+    bool _apfFunc = false;
+    bool _monFunc = false;
+    bool _mnFunc = false;
+    bool _rfFunc = false;
+    bool _aroFunc = false;
+    bool _muteFunc = false;
+    bool _vscFunc = false;
+    bool _revFunc = false;
+    bool _sqlFunc = false;
+    bool _abmFunc = false;
+    bool _bcFunc = false;
+    bool _mbcFunc = false;
+    bool _ritFunc = false;
+    bool _afcFunc = false;
+    bool _satmodeFunc = false;
+    bool _scopeFunc = false;
+    bool _resumeFunc = false;
+    bool _tburstFunc = false;
+    bool _tunerFunc = false;
+    bool _lockFunc = false;
+
+};
+
+#endif
\ No newline at end of file
diff --git a/wfmain.cpp b/wfmain.cpp
index ff1011f..82983dd 100644
--- a/wfmain.cpp
+++ b/wfmain.cpp
@@ -46,6 +46,7 @@ wfmain::wfmain(const QString serialPortCL, const QString hostCL, const QString s
     qRegisterMetaType <audioSetup>();
     qRegisterMetaType <timekind>();
     qRegisterMetaType <datekind>();
+    qRegisterMetaType<rigstate*>();
 
 
     haveRigCaps = false;
@@ -413,7 +414,7 @@ void wfmain::makeRig()
         connect(rig, SIGNAL(commReady()), this, SLOT(receiveCommReady()));
 
         if (rigCtl != Q_NULLPTR) {
-            connect(rig, SIGNAL(stateInfo(rigStateStruct*)), rigCtl, SLOT(receiveStateInfo(rigStateStruct*)));
+            connect(rig, SIGNAL(stateInfo(rigstate*)), rigCtl, SLOT(receiveStateInfo(rigstate*)));
             connect(this, SIGNAL(requestRigState()), rig, SLOT(sendState()));
             connect(rigCtl, SIGNAL(setFrequency(unsigned char, freqt)), rig, SLOT(setFrequency(unsigned char, freqt)));
             connect(rigCtl, SIGNAL(setMode(unsigned char, unsigned char)), rig, SLOT(setMode(unsigned char, unsigned char)));
@@ -421,6 +422,7 @@ void wfmain::makeRig()
             connect(rigCtl, SIGNAL(setPTT(bool)), rig, SLOT(setPTT(bool)));
             connect(rigCtl, SIGNAL(sendPowerOn()), rig, SLOT(powerOn()));
             connect(rigCtl, SIGNAL(sendPowerOff()), rig, SLOT(powerOff()));
+            connect(rigCtl, SIGNAL(stateUpdated()), rig, SLOT(stateUpdated()));
 
             connect(rigCtl, SIGNAL(setAttenuator(unsigned char)), rig, SLOT(setAttenuator(unsigned char)));
             connect(rigCtl, SIGNAL(setPreamp(unsigned char)), rig, SLOT(setPreamp(unsigned char)));
@@ -5444,13 +5446,14 @@ void wfmain::on_enableRigctldChk_clicked(bool checked)
         connect(this, SIGNAL(sendRigCaps(rigCapabilities)), rigCtl, SLOT(receiveRigCaps(rigCapabilities)));
         if (rig != Q_NULLPTR) {
             // We are already connected to a rig.
-            connect(rig, SIGNAL(stateInfo(rigStateStruct*)), rigCtl, SLOT(receiveStateInfo(rigStateStruct*)));
+            connect(rig, SIGNAL(stateInfo(rigstate*)), rigCtl, SLOT(receiveStateInfo(rigstate*)));
             connect(rigCtl, SIGNAL(setFrequency(unsigned char, freqt)), rig, SLOT(setFrequency(unsigned char, freqt)));
             connect(rigCtl, SIGNAL(setMode(unsigned char, unsigned char)), rig, SLOT(setMode(unsigned char, unsigned char)));
             connect(rigCtl, SIGNAL(setDataMode(bool, unsigned char)), rig, SLOT(setDataMode(bool, unsigned char)));
             connect(rigCtl, SIGNAL(setPTT(bool)), rig, SLOT(setPTT(bool)));
             connect(rigCtl, SIGNAL(sendPowerOn()), rig, SLOT(powerOn()));
             connect(rigCtl, SIGNAL(sendPowerOff()), rig, SLOT(powerOff()));
+            connect(rigCtl, SIGNAL(stateUpdated()), rig, SLOT(stateUpdated()));
 
             connect(rigCtl, SIGNAL(setAttenuator(unsigned char)), rig, SLOT(setAttenuator(unsigned char)));
             connect(rigCtl, SIGNAL(setPreamp(unsigned char)), rig, SLOT(setPreamp(unsigned char)));
diff --git a/wfmain.h b/wfmain.h
index b854a48..1b19d7b 100644
--- a/wfmain.h
+++ b/wfmain.h
@@ -14,6 +14,7 @@
 #include "logcategories.h"
 #include "commhandler.h"
 #include "rigcommander.h"
+#include "rigstate.h"
 #include "freqmemory.h"
 #include "rigidentities.h"
 #include "repeaterattributes.h"
@@ -850,7 +851,6 @@ Q_DECLARE_METATYPE(struct rigCapabilities)
 Q_DECLARE_METATYPE(struct freqt)
 Q_DECLARE_METATYPE(struct mode_info)
 Q_DECLARE_METATYPE(struct udpPreferences)
-Q_DECLARE_METATYPE(struct rigStateStruct)
 Q_DECLARE_METATYPE(struct audioPacket)
 Q_DECLARE_METATYPE(struct audioSetup)
 Q_DECLARE_METATYPE(struct timekind)
@@ -858,6 +858,7 @@ Q_DECLARE_METATYPE(struct datekind)
 Q_DECLARE_METATYPE(enum rigInput)
 Q_DECLARE_METATYPE(enum meterKind)
 Q_DECLARE_METATYPE(enum spectrumMode)
+Q_DECLARE_METATYPE(rigstate*)
 
 
 #endif // WFMAIN_H