mirror
/
Hamlib
kopia lustrzana https://github.com/Hamlib/Hamlib
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność

Convert some cache references to pointers 

Affects issue #1420
pull/1508/head
George Baltz N3GB 2024-01-17 03:24:27 -05:00
rodzic 6bfccb3e92
commit bf8bf51bf4
2 zmienionych plików z 191 dodań i 180 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

280
src/cache.c
Wyświetl plik

@ -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);
}
}

91
src/event.c
Wyświetl plik

@ -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);