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

Convert a few more cache pointers 

More of issue #1420
pull/1508/head
George Baltz N3GB 2024-01-17 11:52:23 -05:00
rodzic bf8bf51bf4
commit 96ee58436a
4 zmienionych plików z 74 dodań i 63 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

6
src/misc.c
Wyświetl plik

@ -1975,7 +1975,7 @@ double HAMLIB_API elapsed_ms(struct timespec *start, int option)
int HAMLIB_API rig_get_cache_timeout_ms(RIG *rig, hamlib_cache_t selection)
{
rig_debug(RIG_DEBUG_TRACE, "%s: called selection=%d\n", __func__, selection);
return rig->state.cache.timeout_ms;
return CACHE(rig)->timeout_ms;
}
int HAMLIB_API rig_set_cache_timeout_ms(RIG *rig, hamlib_cache_t selection,
@ -1983,7 +1983,7 @@ int HAMLIB_API rig_set_cache_timeout_ms(RIG *rig, hamlib_cache_t selection,
{
rig_debug(RIG_DEBUG_TRACE, "%s: called selection=%d, ms=%d\n", __func__,
selection, ms);
rig->state.cache.timeout_ms = ms;
CACHE(rig)->timeout_ms = ms;
return RIG_OK;
}
@ -2092,7 +2092,7 @@ vfo_t HAMLIB_API vfo_fixup(RIG *rig, vfo_t vfo, split_t split)
}
else if (vfo == RIG_VFO_TX)
{
int satmode = rig->state.cache.satmode;
int satmode = CACHE(rig)->satmode;
rig_debug(RIG_DEBUG_VERBOSE, "%s(%d): split=%d, vfo==%s tx_vfo=%s\n", __func__,
__LINE__, split, rig_strvfo(vfo), rig_strvfo(rig->state.tx_vfo));

38
src/misc.h
Wyświetl plik

@ -177,25 +177,25 @@ void errmsg(int err, char *s, const char *func, const char *file, int line);
} while(0);}
#define CACHE_RESET {\
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_freqSubA, HAMLIB_ELAPSED_INVALIDATE);\
elapsed_ms(&rig->state.cache.time_freqSubB, 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(&CACHE(rig)->time_freqMainA, HAMLIB_ELAPSED_INVALIDATE);\
elapsed_ms(&CACHE(rig)->time_freqMainB, HAMLIB_ELAPSED_INVALIDATE);\
elapsed_ms(&CACHE(rig)->time_freqSubA, HAMLIB_ELAPSED_INVALIDATE);\
elapsed_ms(&CACHE(rig)->time_freqSubB, HAMLIB_ELAPSED_INVALIDATE);\
elapsed_ms(&CACHE(rig)->time_vfo, HAMLIB_ELAPSED_INVALIDATE);\
elapsed_ms(&CACHE(rig)->time_modeMainA, HAMLIB_ELAPSED_INVALIDATE);\
elapsed_ms(&CACHE(rig)->time_modeMainB, HAMLIB_ELAPSED_INVALIDATE);\
elapsed_ms(&CACHE(rig)->time_modeMainC, HAMLIB_ELAPSED_INVALIDATE);\
elapsed_ms(&CACHE(rig)->time_modeSubA, HAMLIB_ELAPSED_INVALIDATE);\
elapsed_ms(&CACHE(rig)->time_modeSubB, HAMLIB_ELAPSED_INVALIDATE);\
elapsed_ms(&CACHE(rig)->time_modeSubC, HAMLIB_ELAPSED_INVALIDATE);\
elapsed_ms(&CACHE(rig)->time_widthMainA, HAMLIB_ELAPSED_INVALIDATE);\
elapsed_ms(&CACHE(rig)->time_widthMainB, HAMLIB_ELAPSED_INVALIDATE);\
elapsed_ms(&CACHE(rig)->time_widthMainC, HAMLIB_ELAPSED_INVALIDATE);\
elapsed_ms(&CACHE(rig)->time_widthSubA, HAMLIB_ELAPSED_INVALIDATE);\
elapsed_ms(&CACHE(rig)->time_widthSubB, HAMLIB_ELAPSED_INVALIDATE);\
elapsed_ms(&CACHE(rig)->time_widthSubC, HAMLIB_ELAPSED_INVALIDATE);\
elapsed_ms(&CACHE(rig)->time_ptt, HAMLIB_ELAPSED_INVALIDATE);\
elapsed_ms(&CACHE(rig)->time_split, HAMLIB_ELAPSED_INVALIDATE);\
}

79
src/multicast.c
Wyświetl plik

@ -43,8 +43,9 @@ int multicast_stop(RIG *rig)
static int multicast_status_changed(RIG *rig)
{
int retval;
struct rig_cache *cachep = CACHE(rig);
#if 0
freq_t freq, freqsave = rig->state.cache.freqMainA;
freq_t freq, freqsave = cachep->freqMainA;
if ((retval = rig_get_freq(rig, RIG_VFO_A, &freq)) != RIG_OK)
{
@ -55,10 +56,10 @@ static int multicast_status_changed(RIG *rig)
#endif
rmode_t modeA, modeAsave = rig->state.cache.modeMainA;
rmode_t modeB, modeBsave = rig->state.cache.modeMainB;
pbwidth_t widthA, widthAsave = rig->state.cache.widthMainA;
pbwidth_t widthB, widthBsave = rig->state.cache.widthMainB;
rmode_t modeA, modeAsave = cachep->modeMainA;
rmode_t modeB, modeBsave = cachep->modeMainB;
pbwidth_t widthA, widthAsave = cachep->widthMainA;
pbwidth_t widthB, widthBsave = cachep->widthMainB;
#if 0
@ -89,7 +90,7 @@ static int multicast_status_changed(RIG *rig)
if (widthB != widthBsave) { return 1; }
ptt_t ptt, pttsave = rig->state.cache.ptt;
ptt_t ptt, pttsave = cachep->ptt;
#if 0
@ -97,7 +98,7 @@ static int multicast_status_changed(RIG *rig)
&& (retval = rig_get_ptt(rig, RIG_VFO_CURR, &ptt)) != RIG_OK)
if (ptt != pttsave) { return 1; }
split_t split, splitsave = rig->state.cache.split;
split_t split, splitsave = cachep->split;
vfo_t txvfo;
if (rig->state.multicast->seqnumber % 2 == 0
@ -190,47 +191,49 @@ void json_add_time(char *msg, int addComma)
void json_add_vfoA(RIG *rig, char *msg)
{
struct rig_cache *cachep = CACHE(rig);
strcat(msg, "{\n");
json_add_string(msg, "Name", "VFOA", 1);
json_add_int(msg, "Freq", rig->state.cache.freqMainA, 1);
json_add_int(msg, "Freq", cachep->freqMainA, 1);
if (strlen(rig_strrmode(rig->state.cache.modeMainA)) > 0)
if (strlen(rig_strrmode(cachep->modeMainA)) > 0)
{
json_add_string(msg, "Mode", rig_strrmode(rig->state.cache.modeMainA), 1);
json_add_string(msg, "Mode", rig_strrmode(cachep->modeMainA), 1);
}
else
{
json_add_string(msg, "Mode", "None", 1);
}
json_add_int(msg, "Width", rig->state.cache.widthMainA, 0);
json_add_int(msg, "Width", cachep->widthMainA, 0);
#if 0 // not working quite yet
// what about full duplex? rx_vfo would be in rx all the time?
rig_debug(RIG_DEBUG_ERR, "%s: rx_vfo=%s, tx_vfo=%s, split=%d\n", __func__,
rig_strvfo(rig->state.rx_vfo), rig_strvfo(rig->state.tx_vfo),
rig->state.cache.split);
cachep->split);
printf("%s: rx_vfo=%s, tx_vfo=%s, split=%d\n", __func__,
rig_strvfo(rig->state.rx_vfo), rig_strvfo(rig->state.tx_vfo),
rig->state.cache.split);
cachep->split);
if (rig->state.cache.split)
if (cachep->split)
{
if (rig->state.tx_vfo && (RIG_VFO_B | RIG_VFO_MAIN_B))
{
json_add_boolean(msg, "RX", !rig->state.cache.ptt, 1);
json_add_boolean(msg, "RX", !cachep->ptt, 1);
json_add_boolean(msg, "TX", 0, 0);
}
else // we must be in reverse split
{
json_add_boolean(msg, "RX", 0, 1);
json_add_boolean(msg, "TX", rig->state.cache.ptt, 0);
json_add_boolean(msg, "TX", cachep->ptt, 0);
}
}
else if (rig->state.current_vfo && (RIG_VFO_A | RIG_VFO_MAIN_A))
{
json_add_boolean(msg, "RX", !rig->state.cache.ptt, 1);
json_add_boolean(msg, "TX", rig->state.cache.ptt, 0);
json_add_boolean(msg, "RX", !cachep->ptt, 1);
json_add_boolean(msg, "TX", cachep->ptt, 0);
}
else // VFOB must be active so never RX or TX
{
@ -244,40 +247,42 @@ void json_add_vfoA(RIG *rig, char *msg)
void json_add_vfoB(RIG *rig, char *msg)
{
struct rig_cache *cachep = CACHE(rig);
strcat(msg, ",\n{\n");
json_add_string(msg, "Name", "VFOB", 1);
json_add_int(msg, "Freq", rig->state.cache.freqMainB, 1);
json_add_int(msg, "Freq", cachep->freqMainB, 1);
if (strlen(rig_strrmode(rig->state.cache.modeMainB)) > 0)
if (strlen(rig_strrmode(cachep->modeMainB)) > 0)
{
json_add_string(msg, "Mode", rig_strrmode(rig->state.cache.modeMainB), 1);
json_add_string(msg, "Mode", rig_strrmode(cachep->modeMainB), 1);
}
else
{
json_add_string(msg, "Mode", "None", 1);
}
json_add_int(msg, "Width", rig->state.cache.widthMainB, 0);
json_add_int(msg, "Width", cachep->widthMainB, 0);
#if 0 // not working yet
if (rig->state.rx_vfo != rig->state.tx_vfo && rig->state.cache.split)
if (rig->state.rx_vfo != rig->state.tx_vfo && cachep->split)
{
if (rig->state.tx_vfo && (RIG_VFO_B | RIG_VFO_MAIN_B))
{
json_add_boolean(msg, "RX", 0, 1);
json_add_boolean(msg, "TX", rig->state.cache.ptt, 0);
json_add_boolean(msg, "TX", cachep->ptt, 0);
}
else // we must be in reverse split
{
json_add_boolean(msg, "RX", rig->state.cache.ptt, 1);
json_add_boolean(msg, "RX", cachep->ptt, 1);
json_add_boolean(msg, "TX", 0, 0);
}
}
else if (rig->state.current_vfo && (RIG_VFO_A | RIG_VFO_MAIN_A))
{
json_add_boolean(msg, "RX", !rig->state.cache.ptt, 1);
json_add_boolean(msg, "TX", rig->state.cache.ptt, 0);
json_add_boolean(msg, "RX", !cachep->ptt, 1);
json_add_boolean(msg, "TX", cachep->ptt, 0);
}
else // VFOB must be active so always RX or TX
{
@ -294,6 +299,8 @@ static int multicast_send_json(RIG *rig)
{
char msg[8192]; // could be pretty big
char buf[4096];
struct rig_cache *cachep = CACHE(rig);
// sprintf(msg,"%s:f=%.1f", date_strget(msg, (int)sizeof(msg), 0), f);
msg[0] = 0;
snprintf(buf, sizeof(buf), "%s:%s", rig->caps->model_name,
@ -303,8 +310,8 @@ static int multicast_send_json(RIG *rig)
json_add_time(msg, 1);
json_add_int(msg, "Sequence", rig->state.multicast->seqnumber++, 1);
json_add_string(msg, "VFOCurr", rig_strvfo(rig->state.current_vfo), 1);
json_add_int(msg, "PTT", rig->state.cache.ptt, 1);
json_add_int(msg, "Split", rig->state.cache.split, 1);
json_add_int(msg, "PTT", cachep->ptt, 1);
json_add_int(msg, "Split", cachep->split, 1);
rig_sprintf_mode(buf, sizeof(buf), rig->state.mode_list);
json_add_string(msg, "ModeList", buf, 1);
strcat(msg, "\"VFOs\": [\n");
@ -369,6 +376,8 @@ void *multicast_thread(void *vrig)
mode_t modeA, modeAsave = 0;
mode_t modeB, modeBsave = 0;
ptt_t ptt, pttsave = 0;
struct rig_cache *cachep = CACHE(rig);
rig->state.multicast->runflag = 1;
while (rig->state.multicast->runflag)
@ -387,15 +396,15 @@ void *multicast_thread(void *vrig)
}
else
{
freqB = rig->state.cache.freqMainB;
freqB = cachep->freqMainB;
}
#else
freqA = rig->state.cache.freqMainA;
freqB = rig->state.cache.freqMainB;
modeA = rig->state.cache.modeMainA;
modeB = rig->state.cache.modeMainB;
ptt = rig->state.cache.ptt;
freqA = cachep->freqMainA;
freqB = cachep->freqMainB;
modeA = cachep->modeMainA;
modeB = cachep->modeMainB;
ptt = cachep->ptt;
#endif
if (freqA != freqAsave

14
src/snapshot_data.c
Wyświetl plik

@ -19,6 +19,7 @@ static int snapshot_serialize_rig(cJSON *rig_node, RIG *rig)
{
cJSON *node;
char buf[1024];
struct rig_cache *cachep = CACHE(rig);
cJSON *id_node = cJSON_CreateObject();
cJSON_AddStringToObject(id_node, "model", rig->caps->model_name);
@ -51,7 +52,7 @@ static int snapshot_serialize_rig(cJSON *rig_node, RIG *rig)
}
node = cJSON_AddBoolToObject(rig_node, "split",
rig->state.cache.split == RIG_SPLIT_ON ? 1 : 0);
cachep->split == RIG_SPLIT_ON ? 1 : 0);
if (node == NULL)
{
@ -59,7 +60,7 @@ static int snapshot_serialize_rig(cJSON *rig_node, RIG *rig)
}
node = cJSON_AddStringToObject(rig_node, "splitVfo",
rig_strvfo(rig->state.cache.split_vfo));
rig_strvfo(cachep->split_vfo));
if (node == NULL)
{
@ -67,7 +68,7 @@ static int snapshot_serialize_rig(cJSON *rig_node, RIG *rig)
}
node = cJSON_AddBoolToObject(rig_node, "satMode",
rig->state.cache.satmode ? 1 : 0);
cachep->satmode ? 1 : 0);
if (node == NULL)
{
@ -111,6 +112,7 @@ static int snapshot_serialize_vfo(cJSON *vfo_node, RIG *rig, vfo_t vfo)
int result;
int is_rx, is_tx;
cJSON *node;
struct rig_cache *cachep = CACHE(rig);
// TODO: This data should match rig_get_info command response
@ -148,14 +150,14 @@ static int snapshot_serialize_vfo(cJSON *vfo_node, RIG *rig, vfo_t vfo)
}
}
split = rig->state.cache.split;
split_vfo = rig->state.cache.split_vfo;
split = cachep->split;
split_vfo = cachep->split_vfo;
is_rx = (split == RIG_SPLIT_OFF && vfo == rig->state.current_vfo)
|| (split == RIG_SPLIT_ON && vfo != split_vfo);
is_tx = (split == RIG_SPLIT_OFF && vfo == rig->state.current_vfo)
|| (split == RIG_SPLIT_ON && vfo == split_vfo);
ptt = rig->state.cache.ptt && is_tx;
ptt = cachep->ptt && is_tx;
if (is_tx)
{