diff --git a/src/cache.c b/src/cache.c
index a6db507bb..eade385d4 100644
--- a/src/cache.c
+++ b/src/cache.c
@@ -19,6 +19,7 @@
  *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  *
  */
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
 
 #include "cache.h"
 #include "misc.h"
@@ -33,6 +34,8 @@
 
 int rig_set_cache_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
 {
+    struct rig_cache *cachep = CACHE(rig);
+  
     ENTERFUNC;
 
     rig_cache_show(rig, __func__, __LINE__);
@@ -56,9 +59,9 @@ int rig_set_cache_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
     // pick a sane default
     if (vfo == RIG_VFO_NONE || vfo == RIG_VFO_CURR) { vfo = RIG_VFO_A; }
 
-    if (vfo == RIG_VFO_SUB && rig->state.cache.satmode) { vfo = RIG_VFO_SUB_A; };
+    if (vfo == RIG_VFO_SUB && cachep->satmode) { vfo = RIG_VFO_SUB_A; };
 
-    if (vfo == RIG_VFO_OTHER) { vfo = vfo_fixup(rig, vfo, rig->state.cache.split); }
+    if (vfo == RIG_VFO_OTHER) { vfo = vfo_fixup(rig, vfo, cachep->split); }
 
     if (vfo == rig->state.current_vfo)
     {
@@ -73,71 +76,71 @@ int rig_set_cache_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
     switch (vfo)
     {
     case RIG_VFO_ALL: // we'll use NONE to reset all VFO caches
-        elapsed_ms(&rig->state.cache.time_modeMainA, HAMLIB_ELAPSED_INVALIDATE);
-        elapsed_ms(&rig->state.cache.time_modeMainB, HAMLIB_ELAPSED_INVALIDATE);
-        elapsed_ms(&rig->state.cache.time_modeMainC, HAMLIB_ELAPSED_INVALIDATE);
-        elapsed_ms(&rig->state.cache.time_modeSubA, HAMLIB_ELAPSED_INVALIDATE);
-        elapsed_ms(&rig->state.cache.time_modeSubB, HAMLIB_ELAPSED_INVALIDATE);
-        elapsed_ms(&rig->state.cache.time_modeSubC, HAMLIB_ELAPSED_INVALIDATE);
-        elapsed_ms(&rig->state.cache.time_widthMainA, HAMLIB_ELAPSED_INVALIDATE);
-        elapsed_ms(&rig->state.cache.time_widthMainB, HAMLIB_ELAPSED_INVALIDATE);
-        elapsed_ms(&rig->state.cache.time_widthMainC, HAMLIB_ELAPSED_INVALIDATE);
-        elapsed_ms(&rig->state.cache.time_widthSubA, HAMLIB_ELAPSED_INVALIDATE);
-        elapsed_ms(&rig->state.cache.time_widthSubB, HAMLIB_ELAPSED_INVALIDATE);
-        elapsed_ms(&rig->state.cache.time_widthSubC, HAMLIB_ELAPSED_INVALIDATE);
+        elapsed_ms(&cachep->time_modeMainA, HAMLIB_ELAPSED_INVALIDATE);
+        elapsed_ms(&cachep->time_modeMainB, HAMLIB_ELAPSED_INVALIDATE);
+        elapsed_ms(&cachep->time_modeMainC, HAMLIB_ELAPSED_INVALIDATE);
+        elapsed_ms(&cachep->time_modeSubA, HAMLIB_ELAPSED_INVALIDATE);
+        elapsed_ms(&cachep->time_modeSubB, HAMLIB_ELAPSED_INVALIDATE);
+        elapsed_ms(&cachep->time_modeSubC, HAMLIB_ELAPSED_INVALIDATE);
+        elapsed_ms(&cachep->time_widthMainA, HAMLIB_ELAPSED_INVALIDATE);
+        elapsed_ms(&cachep->time_widthMainB, HAMLIB_ELAPSED_INVALIDATE);
+        elapsed_ms(&cachep->time_widthMainC, HAMLIB_ELAPSED_INVALIDATE);
+        elapsed_ms(&cachep->time_widthSubA, HAMLIB_ELAPSED_INVALIDATE);
+        elapsed_ms(&cachep->time_widthSubB, HAMLIB_ELAPSED_INVALIDATE);
+        elapsed_ms(&cachep->time_widthSubC, HAMLIB_ELAPSED_INVALIDATE);
         break;
 
     case RIG_VFO_A:
     case RIG_VFO_VFO:
     case RIG_VFO_MAIN:
     case RIG_VFO_MAIN_A:
-        rig->state.cache.modeMainA = mode;
+        cachep->modeMainA = mode;
 
-        if (width > 0) { rig->state.cache.widthMainA = width; }
+        if (width > 0) { cachep->widthMainA = width; }
 
-        elapsed_ms(&rig->state.cache.time_modeMainA, HAMLIB_ELAPSED_SET);
-        elapsed_ms(&rig->state.cache.time_widthMainA, HAMLIB_ELAPSED_SET);
+        elapsed_ms(&cachep->time_modeMainA, HAMLIB_ELAPSED_SET);
+        elapsed_ms(&cachep->time_widthMainA, HAMLIB_ELAPSED_SET);
         break;
 
     case RIG_VFO_B:
     case RIG_VFO_SUB:
     case RIG_VFO_MAIN_B:
-        rig->state.cache.modeMainB = mode;
+        cachep->modeMainB = mode;
 
-        if (width > 0) { rig->state.cache.widthMainB = width; }
+        if (width > 0) { cachep->widthMainB = width; }
 
-        elapsed_ms(&rig->state.cache.time_modeMainB, HAMLIB_ELAPSED_SET);
-        elapsed_ms(&rig->state.cache.time_widthMainB, HAMLIB_ELAPSED_SET);
+        elapsed_ms(&cachep->time_modeMainB, HAMLIB_ELAPSED_SET);
+        elapsed_ms(&cachep->time_widthMainB, HAMLIB_ELAPSED_SET);
         break;
 
     case RIG_VFO_C:
     case RIG_VFO_MAIN_C:
-        rig->state.cache.modeMainC = mode;
+        cachep->modeMainC = mode;
 
-        if (width > 0) { rig->state.cache.widthMainC = width; }
+        if (width > 0) { cachep->widthMainC = width; }
 
-        elapsed_ms(&rig->state.cache.time_modeMainC, HAMLIB_ELAPSED_SET);
-        elapsed_ms(&rig->state.cache.time_widthMainC, HAMLIB_ELAPSED_SET);
+        elapsed_ms(&cachep->time_modeMainC, HAMLIB_ELAPSED_SET);
+        elapsed_ms(&cachep->time_widthMainC, HAMLIB_ELAPSED_SET);
         break;
 
     case RIG_VFO_SUB_A:
-        rig->state.cache.modeSubA = mode;
-        elapsed_ms(&rig->state.cache.time_modeSubA, HAMLIB_ELAPSED_SET);
+        cachep->modeSubA = mode;
+        elapsed_ms(&cachep->time_modeSubA, HAMLIB_ELAPSED_SET);
         break;
 
     case RIG_VFO_SUB_B:
-        rig->state.cache.modeSubB = mode;
-        elapsed_ms(&rig->state.cache.time_modeSubB, HAMLIB_ELAPSED_SET);
+        cachep->modeSubB = mode;
+        elapsed_ms(&cachep->time_modeSubB, HAMLIB_ELAPSED_SET);
         break;
 
     case RIG_VFO_SUB_C:
-        rig->state.cache.modeSubC = mode;
-        elapsed_ms(&rig->state.cache.time_modeSubC, HAMLIB_ELAPSED_SET);
+        cachep->modeSubC = mode;
+        elapsed_ms(&cachep->time_modeSubC, HAMLIB_ELAPSED_SET);
         break;
 
     case RIG_VFO_MEM:
-        rig->state.cache.modeMem = mode;
-        elapsed_ms(&rig->state.cache.time_modeMem, HAMLIB_ELAPSED_SET);
+        cachep->modeMem = mode;
+        elapsed_ms(&cachep->time_modeMem, HAMLIB_ELAPSED_SET);
         break;
 
     default:
@@ -153,6 +156,7 @@ int rig_set_cache_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
 int rig_set_cache_freq(RIG *rig, vfo_t vfo, freq_t freq)
 {
     int flag = HAMLIB_ELAPSED_SET;
+    struct rig_cache *cachep = CACHE(rig);
 
     if (rig_need_debug(RIG_DEBUG_CACHE))
     {
@@ -175,7 +179,7 @@ int rig_set_cache_freq(RIG *rig, vfo_t vfo, freq_t freq)
     // pick a sane default
     if (vfo == RIG_VFO_NONE || vfo == RIG_VFO_CURR) { vfo = RIG_VFO_A; }
 
-    if (vfo == RIG_VFO_SUB && rig->state.cache.satmode) { vfo = RIG_VFO_SUB_A; };
+    if (vfo == RIG_VFO_SUB && cachep->satmode) { vfo = RIG_VFO_SUB_A; };
 
     if (rig_need_debug(RIG_DEBUG_CACHE))
     {
@@ -186,76 +190,76 @@ int rig_set_cache_freq(RIG *rig, vfo_t vfo, freq_t freq)
 
     if (vfo == rig->state.current_vfo)
     {
-        rig->state.cache.freqCurr = freq;
-        elapsed_ms(&rig->state.cache.time_freqCurr, flag);
+        cachep->freqCurr = freq;
+        elapsed_ms(&cachep->time_freqCurr, flag);
     }
 
     switch (vfo)
     {
     case RIG_VFO_ALL: // we'll use NONE to reset all VFO caches
-        elapsed_ms(&rig->state.cache.time_freqMainA, HAMLIB_ELAPSED_INVALIDATE);
-        elapsed_ms(&rig->state.cache.time_freqMainB, HAMLIB_ELAPSED_INVALIDATE);
-        elapsed_ms(&rig->state.cache.time_freqMainC, HAMLIB_ELAPSED_INVALIDATE);
-        elapsed_ms(&rig->state.cache.time_freqSubA, HAMLIB_ELAPSED_INVALIDATE);
-        elapsed_ms(&rig->state.cache.time_freqSubB, HAMLIB_ELAPSED_INVALIDATE);
-        elapsed_ms(&rig->state.cache.time_freqSubC, HAMLIB_ELAPSED_INVALIDATE);
-        elapsed_ms(&rig->state.cache.time_freqMem, HAMLIB_ELAPSED_INVALIDATE);
-        elapsed_ms(&rig->state.cache.time_vfo, HAMLIB_ELAPSED_INVALIDATE);
-        elapsed_ms(&rig->state.cache.time_modeMainA, HAMLIB_ELAPSED_INVALIDATE);
-        elapsed_ms(&rig->state.cache.time_modeMainB, HAMLIB_ELAPSED_INVALIDATE);
-        elapsed_ms(&rig->state.cache.time_modeMainC, HAMLIB_ELAPSED_INVALIDATE);
-        elapsed_ms(&rig->state.cache.time_modeSubA, HAMLIB_ELAPSED_INVALIDATE);
-        elapsed_ms(&rig->state.cache.time_modeSubB, HAMLIB_ELAPSED_INVALIDATE);
-        elapsed_ms(&rig->state.cache.time_modeSubC, HAMLIB_ELAPSED_INVALIDATE);
-        elapsed_ms(&rig->state.cache.time_widthMainA, HAMLIB_ELAPSED_INVALIDATE);
-        elapsed_ms(&rig->state.cache.time_widthMainB, HAMLIB_ELAPSED_INVALIDATE);
-        elapsed_ms(&rig->state.cache.time_widthMainC, HAMLIB_ELAPSED_INVALIDATE);
-        elapsed_ms(&rig->state.cache.time_widthSubA, HAMLIB_ELAPSED_INVALIDATE);
-        elapsed_ms(&rig->state.cache.time_widthSubB, HAMLIB_ELAPSED_INVALIDATE);
-        elapsed_ms(&rig->state.cache.time_widthSubC, HAMLIB_ELAPSED_INVALIDATE);
-        elapsed_ms(&rig->state.cache.time_ptt, HAMLIB_ELAPSED_INVALIDATE);
-        elapsed_ms(&rig->state.cache.time_split, HAMLIB_ELAPSED_INVALIDATE);
+        elapsed_ms(&cachep->time_freqMainA, HAMLIB_ELAPSED_INVALIDATE);
+        elapsed_ms(&cachep->time_freqMainB, HAMLIB_ELAPSED_INVALIDATE);
+        elapsed_ms(&cachep->time_freqMainC, HAMLIB_ELAPSED_INVALIDATE);
+        elapsed_ms(&cachep->time_freqSubA, HAMLIB_ELAPSED_INVALIDATE);
+        elapsed_ms(&cachep->time_freqSubB, HAMLIB_ELAPSED_INVALIDATE);
+        elapsed_ms(&cachep->time_freqSubC, HAMLIB_ELAPSED_INVALIDATE);
+        elapsed_ms(&cachep->time_freqMem, HAMLIB_ELAPSED_INVALIDATE);
+        elapsed_ms(&cachep->time_vfo, HAMLIB_ELAPSED_INVALIDATE);
+        elapsed_ms(&cachep->time_modeMainA, HAMLIB_ELAPSED_INVALIDATE);
+        elapsed_ms(&cachep->time_modeMainB, HAMLIB_ELAPSED_INVALIDATE);
+        elapsed_ms(&cachep->time_modeMainC, HAMLIB_ELAPSED_INVALIDATE);
+        elapsed_ms(&cachep->time_modeSubA, HAMLIB_ELAPSED_INVALIDATE);
+        elapsed_ms(&cachep->time_modeSubB, HAMLIB_ELAPSED_INVALIDATE);
+        elapsed_ms(&cachep->time_modeSubC, HAMLIB_ELAPSED_INVALIDATE);
+        elapsed_ms(&cachep->time_widthMainA, HAMLIB_ELAPSED_INVALIDATE);
+        elapsed_ms(&cachep->time_widthMainB, HAMLIB_ELAPSED_INVALIDATE);
+        elapsed_ms(&cachep->time_widthMainC, HAMLIB_ELAPSED_INVALIDATE);
+        elapsed_ms(&cachep->time_widthSubA, HAMLIB_ELAPSED_INVALIDATE);
+        elapsed_ms(&cachep->time_widthSubB, HAMLIB_ELAPSED_INVALIDATE);
+        elapsed_ms(&cachep->time_widthSubC, HAMLIB_ELAPSED_INVALIDATE);
+        elapsed_ms(&cachep->time_ptt, HAMLIB_ELAPSED_INVALIDATE);
+        elapsed_ms(&cachep->time_split, HAMLIB_ELAPSED_INVALIDATE);
         break;
 
     case RIG_VFO_A:
     case RIG_VFO_VFO:
     case RIG_VFO_MAIN:
     case RIG_VFO_MAIN_A:
-        rig->state.cache.freqMainA = freq;
-        elapsed_ms(&rig->state.cache.time_freqMainA, flag);
+        cachep->freqMainA = freq;
+        elapsed_ms(&cachep->time_freqMainA, flag);
         break;
 
     case RIG_VFO_B:
     case RIG_VFO_MAIN_B:
     case RIG_VFO_SUB:
-        rig->state.cache.freqMainB = freq;
-        elapsed_ms(&rig->state.cache.time_freqMainB, flag);
+        cachep->freqMainB = freq;
+        elapsed_ms(&cachep->time_freqMainB, flag);
         break;
 
     case RIG_VFO_C:
     case RIG_VFO_MAIN_C:
-        rig->state.cache.freqMainC = freq;
-        elapsed_ms(&rig->state.cache.time_freqMainC, flag);
+        cachep->freqMainC = freq;
+        elapsed_ms(&cachep->time_freqMainC, flag);
         break;
 
     case RIG_VFO_SUB_A:
-        rig->state.cache.freqSubA = freq;
-        elapsed_ms(&rig->state.cache.time_freqSubA, flag);
+        cachep->freqSubA = freq;
+        elapsed_ms(&cachep->time_freqSubA, flag);
         break;
 
     case RIG_VFO_SUB_B:
-        rig->state.cache.freqSubB = freq;
-        elapsed_ms(&rig->state.cache.time_freqSubB, flag);
+        cachep->freqSubB = freq;
+        elapsed_ms(&cachep->time_freqSubB, flag);
         break;
 
     case RIG_VFO_SUB_C:
-        rig->state.cache.freqSubC = freq;
-        elapsed_ms(&rig->state.cache.time_freqSubC, flag);
+        cachep->freqSubC = freq;
+        elapsed_ms(&cachep->time_freqSubC, flag);
         break;
 
     case RIG_VFO_MEM:
-        rig->state.cache.freqMem = freq;
-        elapsed_ms(&rig->state.cache.time_freqMem, flag);
+        cachep->freqMem = freq;
+        elapsed_ms(&cachep->time_freqMem, flag);
         break;
 
     case RIG_VFO_OTHER:
@@ -302,6 +306,8 @@ int rig_set_cache_freq(RIG *rig, vfo_t vfo, freq_t freq)
 int rig_get_cache(RIG *rig, vfo_t vfo, freq_t *freq, int *cache_ms_freq,
                   rmode_t *mode, int *cache_ms_mode, pbwidth_t *width, int *cache_ms_width)
 {
+    struct rig_cache *cachep = CACHE(rig);
+  
     if (CHECK_RIG_ARG(rig) || !freq || !cache_ms_freq ||
             !mode || !cache_ms_mode || !width || !cache_ms_width)
     {
@@ -386,31 +392,31 @@ int rig_get_cache(RIG *rig, vfo_t vfo, freq_t *freq, int *cache_ms_freq,
     if (vfo == RIG_VFO_CURR || vfo == RIG_VFO_NONE) { vfo = RIG_VFO_A; }
 
     // If we're in satmode we map SUB to SUB_A
-    if (vfo == RIG_VFO_SUB && rig->state.cache.satmode) { vfo = RIG_VFO_SUB_A; };
+    if (vfo == RIG_VFO_SUB && cachep->satmode) { vfo = RIG_VFO_SUB_A; };
 
     switch (vfo)
     {
     case RIG_VFO_CURR:
-        *freq = rig->state.cache.freqCurr;
-        *mode = rig->state.cache.modeCurr;
-        *width = rig->state.cache.widthCurr;
-        *cache_ms_freq = elapsed_ms(&rig->state.cache.time_freqCurr,
+        *freq = cachep->freqCurr;
+        *mode = cachep->modeCurr;
+        *width = cachep->widthCurr;
+        *cache_ms_freq = elapsed_ms(&cachep->time_freqCurr,
                                     HAMLIB_ELAPSED_GET);
-        *cache_ms_mode = elapsed_ms(&rig->state.cache.time_modeCurr,
+        *cache_ms_mode = elapsed_ms(&cachep->time_modeCurr,
                                     HAMLIB_ELAPSED_GET);
-        *cache_ms_width = elapsed_ms(&rig->state.cache.time_widthCurr,
+        *cache_ms_width = elapsed_ms(&cachep->time_widthCurr,
                                      HAMLIB_ELAPSED_GET);
         break;
 
     case RIG_VFO_OTHER:
-        *freq = rig->state.cache.freqOther;
-        *mode = rig->state.cache.modeOther;
-        *width = rig->state.cache.widthOther;
-        *cache_ms_freq = elapsed_ms(&rig->state.cache.time_freqOther,
+        *freq = cachep->freqOther;
+        *mode = cachep->modeOther;
+        *width = cachep->widthOther;
+        *cache_ms_freq = elapsed_ms(&cachep->time_freqOther,
                                     HAMLIB_ELAPSED_GET);
-        *cache_ms_mode = elapsed_ms(&rig->state.cache.time_modeOther,
+        *cache_ms_mode = elapsed_ms(&cachep->time_modeOther,
                                     HAMLIB_ELAPSED_GET);
-        *cache_ms_width = elapsed_ms(&rig->state.cache.time_widthOther,
+        *cache_ms_width = elapsed_ms(&cachep->time_widthOther,
                                      HAMLIB_ELAPSED_GET);
         break;
 
@@ -418,87 +424,87 @@ int rig_get_cache(RIG *rig, vfo_t vfo, freq_t *freq, int *cache_ms_freq,
     case RIG_VFO_VFO:
     case RIG_VFO_MAIN:
     case RIG_VFO_MAIN_A:
-        *freq = rig->state.cache.freqMainA;
-        *mode = rig->state.cache.modeMainA;
-        *width = rig->state.cache.widthMainA;
-        *cache_ms_freq = elapsed_ms(&rig->state.cache.time_freqMainA,
+        *freq = cachep->freqMainA;
+        *mode = cachep->modeMainA;
+        *width = cachep->widthMainA;
+        *cache_ms_freq = elapsed_ms(&cachep->time_freqMainA,
                                     HAMLIB_ELAPSED_GET);
-        *cache_ms_mode = elapsed_ms(&rig->state.cache.time_modeMainA,
+        *cache_ms_mode = elapsed_ms(&cachep->time_modeMainA,
                                     HAMLIB_ELAPSED_GET);
-        *cache_ms_width = elapsed_ms(&rig->state.cache.time_widthMainA,
+        *cache_ms_width = elapsed_ms(&cachep->time_widthMainA,
                                      HAMLIB_ELAPSED_GET);
         break;
 
     case RIG_VFO_B:
     case RIG_VFO_SUB:
     case RIG_VFO_MAIN_B:
-        *freq = rig->state.cache.freqMainB;
-        *mode = rig->state.cache.modeMainB;
-        *width = rig->state.cache.widthMainB;
-        *cache_ms_freq = elapsed_ms(&rig->state.cache.time_freqMainB,
+        *freq = cachep->freqMainB;
+        *mode = cachep->modeMainB;
+        *width = cachep->widthMainB;
+        *cache_ms_freq = elapsed_ms(&cachep->time_freqMainB,
                                     HAMLIB_ELAPSED_GET);
-        *cache_ms_mode = elapsed_ms(&rig->state.cache.time_modeMainB,
+        *cache_ms_mode = elapsed_ms(&cachep->time_modeMainB,
                                     HAMLIB_ELAPSED_GET);
-        *cache_ms_width = elapsed_ms(&rig->state.cache.time_widthMainB,
+        *cache_ms_width = elapsed_ms(&cachep->time_widthMainB,
                                      HAMLIB_ELAPSED_GET);
         break;
 
     case RIG_VFO_SUB_A:
-        *freq = rig->state.cache.freqSubA;
-        *mode = rig->state.cache.modeSubA;
-        *width = rig->state.cache.widthSubA;
-        *cache_ms_freq = elapsed_ms(&rig->state.cache.time_freqSubA,
+        *freq = cachep->freqSubA;
+        *mode = cachep->modeSubA;
+        *width = cachep->widthSubA;
+        *cache_ms_freq = elapsed_ms(&cachep->time_freqSubA,
                                     HAMLIB_ELAPSED_GET);
-        *cache_ms_mode = elapsed_ms(&rig->state.cache.time_modeSubA,
+        *cache_ms_mode = elapsed_ms(&cachep->time_modeSubA,
                                     HAMLIB_ELAPSED_GET);
-        *cache_ms_width = elapsed_ms(&rig->state.cache.time_widthSubA,
+        *cache_ms_width = elapsed_ms(&cachep->time_widthSubA,
                                      HAMLIB_ELAPSED_GET);
         break;
 
     case RIG_VFO_SUB_B:
-        *freq = rig->state.cache.freqSubB;
-        *mode = rig->state.cache.modeSubB;
-        *width = rig->state.cache.widthSubB;
-        *cache_ms_freq = elapsed_ms(&rig->state.cache.time_freqSubB,
+        *freq = cachep->freqSubB;
+        *mode = cachep->modeSubB;
+        *width = cachep->widthSubB;
+        *cache_ms_freq = elapsed_ms(&cachep->time_freqSubB,
                                     HAMLIB_ELAPSED_GET);
-        *cache_ms_mode = elapsed_ms(&rig->state.cache.time_modeSubB,
+        *cache_ms_mode = elapsed_ms(&cachep->time_modeSubB,
                                     HAMLIB_ELAPSED_GET);
-        *cache_ms_width = elapsed_ms(&rig->state.cache.time_widthSubB,
+        *cache_ms_width = elapsed_ms(&cachep->time_widthSubB,
                                      HAMLIB_ELAPSED_GET);
         break;
 
     case RIG_VFO_C:
         //case RIG_VFO_MAINC: // not used by any rig yet
-        *freq = rig->state.cache.freqMainC;
-        *mode = rig->state.cache.modeMainC;
-        *width = rig->state.cache.widthMainC;
-        *cache_ms_freq = elapsed_ms(&rig->state.cache.time_freqMainC,
+        *freq = cachep->freqMainC;
+        *mode = cachep->modeMainC;
+        *width = cachep->widthMainC;
+        *cache_ms_freq = elapsed_ms(&cachep->time_freqMainC,
                                     HAMLIB_ELAPSED_GET);
-        *cache_ms_mode = elapsed_ms(&rig->state.cache.time_modeMainC,
+        *cache_ms_mode = elapsed_ms(&cachep->time_modeMainC,
                                     HAMLIB_ELAPSED_GET);
-        *cache_ms_width = elapsed_ms(&rig->state.cache.time_widthMainC,
+        *cache_ms_width = elapsed_ms(&cachep->time_widthMainC,
                                      HAMLIB_ELAPSED_GET);
         break;
 
     case RIG_VFO_SUB_C:
-        *freq = rig->state.cache.freqSubC;
-        *mode = rig->state.cache.modeSubC;
-        *width = rig->state.cache.widthSubC;
-        *cache_ms_freq = elapsed_ms(&rig->state.cache.time_freqSubC,
+        *freq = cachep->freqSubC;
+        *mode = cachep->modeSubC;
+        *width = cachep->widthSubC;
+        *cache_ms_freq = elapsed_ms(&cachep->time_freqSubC,
                                     HAMLIB_ELAPSED_GET);
-        *cache_ms_mode = elapsed_ms(&rig->state.cache.time_modeSubC,
+        *cache_ms_mode = elapsed_ms(&cachep->time_modeSubC,
                                     HAMLIB_ELAPSED_GET);
-        *cache_ms_width = elapsed_ms(&rig->state.cache.time_widthSubC,
+        *cache_ms_width = elapsed_ms(&cachep->time_widthSubC,
                                      HAMLIB_ELAPSED_GET);
         break;
 
     case RIG_VFO_MEM:
-        *freq = rig->state.cache.freqMem;
-        *mode = rig->state.cache.modeMem;
-        *width = rig->state.cache.widthMem;
-        *cache_ms_freq = elapsed_ms(&rig->state.cache.time_freqMem, HAMLIB_ELAPSED_GET);
-        *cache_ms_mode = elapsed_ms(&rig->state.cache.time_modeMem, HAMLIB_ELAPSED_GET);
-        *cache_ms_width = elapsed_ms(&rig->state.cache.time_widthMem,
+        *freq = cachep->freqMem;
+        *mode = cachep->modeMem;
+        *width = cachep->widthMem;
+        *cache_ms_freq = elapsed_ms(&cachep->time_freqMem, HAMLIB_ELAPSED_GET);
+        *cache_ms_mode = elapsed_ms(&cachep->time_modeMem, HAMLIB_ELAPSED_GET);
+        *cache_ms_width = elapsed_ms(&cachep->time_widthMem,
                                      HAMLIB_ELAPSED_GET);
         break;
 
@@ -557,25 +563,27 @@ int rig_get_cache_freq(RIG *rig, vfo_t vfo, freq_t *freq, int *cache_ms_freq_p)
 
 void rig_cache_show(RIG *rig, const char *func, int line)
 {
+    struct rig_cache *cachep = CACHE(rig);
+  
     rig_debug(RIG_DEBUG_CACHE,
               "%s(%d): freqMainA=%.0f, modeMainA=%s, widthMainA=%d\n", func, line,
-              rig->state.cache.freqMainA, rig_strrmode(rig->state.cache.modeMainA),
-              (int)rig->state.cache.widthMainA);
+              cachep->freqMainA, rig_strrmode(cachep->modeMainA),
+              (int)cachep->widthMainA);
     rig_debug(RIG_DEBUG_CACHE,
               "%s(%d): freqMainB=%.0f, modeMainB=%s, widthMainB=%d\n", func, line,
-              rig->state.cache.freqMainB, rig_strrmode(rig->state.cache.modeMainB),
-              (int)rig->state.cache.widthMainB);
+              cachep->freqMainB, rig_strrmode(cachep->modeMainB),
+              (int)cachep->widthMainB);
 
     if (rig->state.vfo_list & RIG_VFO_SUB_A)
     {
         rig_debug(RIG_DEBUG_CACHE,
                   "%s(%d): freqSubA=%.0f, modeSubA=%s, widthSubA=%d\n", func, line,
-                  rig->state.cache.freqSubA, rig_strrmode(rig->state.cache.modeSubA),
-                  (int)rig->state.cache.widthSubA);
+                  cachep->freqSubA, rig_strrmode(cachep->modeSubA),
+                  (int)cachep->widthSubA);
         rig_debug(RIG_DEBUG_CACHE,
                   "%s(%d): freqSubB=%.0f, modeSubB=%s, widthSubB=%d\n", func, line,
-                  rig->state.cache.freqSubB, rig_strrmode(rig->state.cache.modeSubB),
-                  (int)rig->state.cache.widthSubB);
+                  cachep->freqSubB, rig_strrmode(cachep->modeSubB),
+                  (int)cachep->widthSubB);
     }
 }
 
diff --git a/src/event.c b/src/event.c
index 342186db9..cebb39c3e 100644
--- a/src/event.c
+++ b/src/event.c
@@ -69,6 +69,7 @@ void *rig_poll_routine(void *arg)
     rig_poll_routine_args *args = (rig_poll_routine_args *)arg;
     RIG *rig = args->rig;
     struct rig_state *rs = &rig->state;
+    struct rig_cache *cachep = CACHE(rig);
     int update_occurred;
 
     vfo_t vfo = RIG_VFO_NONE, tx_vfo = RIG_VFO_NONE;
@@ -109,123 +110,123 @@ void *rig_poll_routine(void *arg)
             update_occurred = 1;
         }
 
-        if (rig->state.cache.freqMainA != freq_main_a)
+        if (cachep->freqMainA != freq_main_a)
         {
-            freq_main_a = rig->state.cache.freqMainA;
+            freq_main_a = cachep->freqMainA;
             update_occurred = 1;
         }
 
-        if (rig->state.cache.freqMainB != freq_main_b)
+        if (cachep->freqMainB != freq_main_b)
         {
-            freq_main_b = rig->state.cache.freqMainB;
+            freq_main_b = cachep->freqMainB;
             update_occurred = 1;
         }
 
-        if (rig->state.cache.freqMainC != freq_main_c)
+        if (cachep->freqMainC != freq_main_c)
         {
-            freq_main_b = rig->state.cache.freqMainC;
+            freq_main_b = cachep->freqMainC;
             update_occurred = 1;
         }
 
-        if (rig->state.cache.freqSubA != freq_sub_a)
+        if (cachep->freqSubA != freq_sub_a)
         {
-            freq_sub_a = rig->state.cache.freqSubA;
+            freq_sub_a = cachep->freqSubA;
             update_occurred = 1;
         }
 
-        if (rig->state.cache.freqSubB != freq_sub_b)
+        if (cachep->freqSubB != freq_sub_b)
         {
-            freq_sub_b = rig->state.cache.freqSubB;
+            freq_sub_b = cachep->freqSubB;
             update_occurred = 1;
         }
 
-        if (rig->state.cache.freqSubC != freq_sub_c)
+        if (cachep->freqSubC != freq_sub_c)
         {
-            freq_sub_c = rig->state.cache.freqSubC;
+            freq_sub_c = cachep->freqSubC;
             update_occurred = 1;
         }
 
-        if (rig->state.cache.ptt != ptt)
+        if (cachep->ptt != ptt)
         {
-            ptt = rig->state.cache.ptt;
+            ptt = cachep->ptt;
             update_occurred = 1;
         }
 
-        if (rig->state.cache.split != split)
+        if (cachep->split != split)
         {
-            split = rig->state.cache.split;
+            split = cachep->split;
             update_occurred = 1;
         }
 
-        if (rig->state.cache.modeMainA != mode_main_a)
+        if (cachep->modeMainA != mode_main_a)
         {
-            mode_main_a = rig->state.cache.modeMainA;
+            mode_main_a = cachep->modeMainA;
             update_occurred = 1;
         }
 
-        if (rig->state.cache.modeMainB != mode_main_b)
+        if (cachep->modeMainB != mode_main_b)
         {
-            mode_main_b = rig->state.cache.modeMainB;
+            mode_main_b = cachep->modeMainB;
             update_occurred = 1;
         }
 
-        if (rig->state.cache.modeMainC != mode_main_c)
+        if (cachep->modeMainC != mode_main_c)
         {
-            mode_main_c = rig->state.cache.modeMainC;
+            mode_main_c = cachep->modeMainC;
             update_occurred = 1;
         }
 
-        if (rig->state.cache.modeSubA != mode_sub_a)
+        if (cachep->modeSubA != mode_sub_a)
         {
-            mode_sub_a = rig->state.cache.modeSubA;
+            mode_sub_a = cachep->modeSubA;
             update_occurred = 1;
         }
 
-        if (rig->state.cache.modeSubB != mode_sub_b)
+        if (cachep->modeSubB != mode_sub_b)
         {
-            mode_sub_b = rig->state.cache.modeSubB;
+            mode_sub_b = cachep->modeSubB;
             update_occurred = 1;
         }
 
-        if (rig->state.cache.modeSubC != mode_sub_c)
+        if (cachep->modeSubC != mode_sub_c)
         {
-            mode_sub_c = rig->state.cache.modeSubC;
+            mode_sub_c = cachep->modeSubC;
             update_occurred = 1;
         }
 
-        if (rig->state.cache.widthMainA != width_main_a)
+        if (cachep->widthMainA != width_main_a)
         {
-            width_main_a = rig->state.cache.widthMainA;
+            width_main_a = cachep->widthMainA;
             update_occurred = 1;
         }
 
-        if (rig->state.cache.widthMainB != width_main_b)
+        if (cachep->widthMainB != width_main_b)
         {
-            width_main_b = rig->state.cache.widthMainB;
+            width_main_b = cachep->widthMainB;
             update_occurred = 1;
         }
 
-        if (rig->state.cache.widthMainC != width_main_c)
+        if (cachep->widthMainC != width_main_c)
         {
-            width_main_c = rig->state.cache.widthMainC;
+            width_main_c = cachep->widthMainC;
             update_occurred = 1;
         }
 
-        if (rig->state.cache.widthSubA != width_sub_a)
+        if (cachep->widthSubA != width_sub_a)
         {
-            width_sub_a = rig->state.cache.widthSubA;
+            width_sub_a = cachep->widthSubA;
             update_occurred = 1;
         }
 
-        if (rig->state.cache.widthSubB != width_sub_b)
+        if (cachep->widthSubB != width_sub_b)
         {
-            width_sub_b = rig->state.cache.widthSubB;
+            width_sub_b = cachep->widthSubB;
             update_occurred = 1;
         }
 
-        if (rig->state.cache.widthSubC != width_sub_c)
+        if (cachep->widthSubC != width_sub_c)
         {
-            width_sub_c = rig->state.cache.widthSubC;
+            width_sub_c = cachep->widthSubC;
             update_occurred = 1;
         }
 
@@ -669,12 +670,13 @@ int rig_fire_mode_event(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
 #if defined(HAVE_PTHREAD)
 int rig_fire_vfo_event(RIG *rig, vfo_t vfo)
 {
+    struct rig_cache *cachep = CACHE(rig);
     ENTERFUNC;
 
     rig_debug(RIG_DEBUG_TRACE, "Event: vfo changed to %s\n", rig_strvfo(vfo));
 
-    rig->state.cache.vfo = vfo;
-    elapsed_ms(&rig->state.cache.time_vfo, HAMLIB_ELAPSED_SET);
+    cachep->vfo = vfo;
+    elapsed_ms(&cachep->time_vfo, HAMLIB_ELAPSED_SET);
 
     network_publish_rig_transceive_data(rig);
 
@@ -691,13 +693,14 @@ int rig_fire_vfo_event(RIG *rig, vfo_t vfo)
 #if defined(HAVE_PTHREAD)
 int rig_fire_ptt_event(RIG *rig, vfo_t vfo, ptt_t ptt)
 {
+    struct rig_cache *cachep = CACHE(rig);
     ENTERFUNC;
 
     rig_debug(RIG_DEBUG_TRACE, "Event: PTT changed to %i on %s\n", ptt,
               rig_strvfo(vfo));
 
-    rig->state.cache.ptt = ptt;
-    elapsed_ms(&rig->state.cache.time_ptt, HAMLIB_ELAPSED_SET);
+    cachep->ptt = ptt;
+    elapsed_ms(&cachep->time_ptt, HAMLIB_ELAPSED_SET);
 
     network_publish_rig_transceive_data(rig);