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) 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); 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, 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__, rig_debug(RIG_DEBUG_TRACE, "%s: called selection=%d, ms=%d\n", __func__,
selection, ms); selection, ms);
rig->state.cache.timeout_ms = ms; CACHE(rig)->timeout_ms = ms;
return RIG_OK; 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) 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__, 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)); __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);} } while(0);}
#define CACHE_RESET {\ #define CACHE_RESET {\
elapsed_ms(&rig->state.cache.time_freqMainA, HAMLIB_ELAPSED_INVALIDATE);\ elapsed_ms(&CACHE(rig)->time_freqMainA, HAMLIB_ELAPSED_INVALIDATE);\
elapsed_ms(&rig->state.cache.time_freqMainB, HAMLIB_ELAPSED_INVALIDATE);\ elapsed_ms(&CACHE(rig)->time_freqMainB, HAMLIB_ELAPSED_INVALIDATE);\
elapsed_ms(&rig->state.cache.time_freqSubA, HAMLIB_ELAPSED_INVALIDATE);\ elapsed_ms(&CACHE(rig)->time_freqSubA, HAMLIB_ELAPSED_INVALIDATE);\
elapsed_ms(&rig->state.cache.time_freqSubB, HAMLIB_ELAPSED_INVALIDATE);\ elapsed_ms(&CACHE(rig)->time_freqSubB, HAMLIB_ELAPSED_INVALIDATE);\
elapsed_ms(&rig->state.cache.time_vfo, HAMLIB_ELAPSED_INVALIDATE);\ elapsed_ms(&CACHE(rig)->time_vfo, HAMLIB_ELAPSED_INVALIDATE);\
elapsed_ms(&rig->state.cache.time_modeMainA, HAMLIB_ELAPSED_INVALIDATE);\ elapsed_ms(&CACHE(rig)->time_modeMainA, HAMLIB_ELAPSED_INVALIDATE);\
elapsed_ms(&rig->state.cache.time_modeMainB, HAMLIB_ELAPSED_INVALIDATE);\ elapsed_ms(&CACHE(rig)->time_modeMainB, HAMLIB_ELAPSED_INVALIDATE);\
elapsed_ms(&rig->state.cache.time_modeMainC, HAMLIB_ELAPSED_INVALIDATE);\ elapsed_ms(&CACHE(rig)->time_modeMainC, HAMLIB_ELAPSED_INVALIDATE);\
elapsed_ms(&rig->state.cache.time_modeSubA, HAMLIB_ELAPSED_INVALIDATE);\ elapsed_ms(&CACHE(rig)->time_modeSubA, HAMLIB_ELAPSED_INVALIDATE);\
elapsed_ms(&rig->state.cache.time_modeSubB, HAMLIB_ELAPSED_INVALIDATE);\ elapsed_ms(&CACHE(rig)->time_modeSubB, HAMLIB_ELAPSED_INVALIDATE);\
elapsed_ms(&rig->state.cache.time_modeSubC, HAMLIB_ELAPSED_INVALIDATE);\ elapsed_ms(&CACHE(rig)->time_modeSubC, HAMLIB_ELAPSED_INVALIDATE);\
elapsed_ms(&rig->state.cache.time_widthMainA, HAMLIB_ELAPSED_INVALIDATE);\ elapsed_ms(&CACHE(rig)->time_widthMainA, HAMLIB_ELAPSED_INVALIDATE);\
elapsed_ms(&rig->state.cache.time_widthMainB, HAMLIB_ELAPSED_INVALIDATE);\ elapsed_ms(&CACHE(rig)->time_widthMainB, HAMLIB_ELAPSED_INVALIDATE);\
elapsed_ms(&rig->state.cache.time_widthMainC, HAMLIB_ELAPSED_INVALIDATE);\ elapsed_ms(&CACHE(rig)->time_widthMainC, HAMLIB_ELAPSED_INVALIDATE);\
elapsed_ms(&rig->state.cache.time_widthSubA, HAMLIB_ELAPSED_INVALIDATE);\ elapsed_ms(&CACHE(rig)->time_widthSubA, HAMLIB_ELAPSED_INVALIDATE);\
elapsed_ms(&rig->state.cache.time_widthSubB, HAMLIB_ELAPSED_INVALIDATE);\ elapsed_ms(&CACHE(rig)->time_widthSubB, HAMLIB_ELAPSED_INVALIDATE);\
elapsed_ms(&rig->state.cache.time_widthSubC, HAMLIB_ELAPSED_INVALIDATE);\ elapsed_ms(&CACHE(rig)->time_widthSubC, HAMLIB_ELAPSED_INVALIDATE);\
elapsed_ms(&rig->state.cache.time_ptt, HAMLIB_ELAPSED_INVALIDATE);\ elapsed_ms(&CACHE(rig)->time_ptt, HAMLIB_ELAPSED_INVALIDATE);\
elapsed_ms(&rig->state.cache.time_split, 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) static int multicast_status_changed(RIG *rig)
{ {
int retval; int retval;
struct rig_cache *cachep = CACHE(rig);
#if 0 #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) if ((retval = rig_get_freq(rig, RIG_VFO_A, &freq)) != RIG_OK)
{ {
@ -55,10 +56,10 @@ static int multicast_status_changed(RIG *rig)
#endif #endif
rmode_t modeA, modeAsave = rig->state.cache.modeMainA; rmode_t modeA, modeAsave = cachep->modeMainA;
rmode_t modeB, modeBsave = rig->state.cache.modeMainB; rmode_t modeB, modeBsave = cachep->modeMainB;
pbwidth_t widthA, widthAsave = rig->state.cache.widthMainA; pbwidth_t widthA, widthAsave = cachep->widthMainA;
pbwidth_t widthB, widthBsave = rig->state.cache.widthMainB; pbwidth_t widthB, widthBsave = cachep->widthMainB;
#if 0 #if 0
@ -89,7 +90,7 @@ static int multicast_status_changed(RIG *rig)
if (widthB != widthBsave) { return 1; } if (widthB != widthBsave) { return 1; }
ptt_t ptt, pttsave = rig->state.cache.ptt; ptt_t ptt, pttsave = cachep->ptt;
#if 0 #if 0
@ -97,7 +98,7 @@ static int multicast_status_changed(RIG *rig)
&& (retval = rig_get_ptt(rig, RIG_VFO_CURR, &ptt)) != RIG_OK) && (retval = rig_get_ptt(rig, RIG_VFO_CURR, &ptt)) != RIG_OK)
if (ptt != pttsave) { return 1; } if (ptt != pttsave) { return 1; }
split_t split, splitsave = rig->state.cache.split; split_t split, splitsave = cachep->split;
vfo_t txvfo; vfo_t txvfo;
if (rig->state.multicast->seqnumber % 2 == 0 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) void json_add_vfoA(RIG *rig, char *msg)
{ {
struct rig_cache *cachep = CACHE(rig);
strcat(msg, "{\n"); strcat(msg, "{\n");
json_add_string(msg, "Name", "VFOA", 1); 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 else
{ {
json_add_string(msg, "Mode", "None", 1); 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 #if 0 // not working quite yet
// what about full duplex? rx_vfo would be in rx all the time? // 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_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_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__, 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_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)) 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); json_add_boolean(msg, "TX", 0, 0);
} }
else // we must be in reverse split else // we must be in reverse split
{ {
json_add_boolean(msg, "RX", 0, 1); 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)) 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, "RX", !cachep->ptt, 1);
json_add_boolean(msg, "TX", rig->state.cache.ptt, 0); json_add_boolean(msg, "TX", cachep->ptt, 0);
} }
else // VFOB must be active so never RX or TX 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) void json_add_vfoB(RIG *rig, char *msg)
{ {
struct rig_cache *cachep = CACHE(rig);
strcat(msg, ",\n{\n"); strcat(msg, ",\n{\n");
json_add_string(msg, "Name", "VFOB", 1); 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 else
{ {
json_add_string(msg, "Mode", "None", 1); 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 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)) if (rig->state.tx_vfo && (RIG_VFO_B | RIG_VFO_MAIN_B))
{ {
json_add_boolean(msg, "RX", 0, 1); 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 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); json_add_boolean(msg, "TX", 0, 0);
} }
} }
else if (rig->state.current_vfo && (RIG_VFO_A | RIG_VFO_MAIN_A)) 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, "RX", !cachep->ptt, 1);
json_add_boolean(msg, "TX", rig->state.cache.ptt, 0); json_add_boolean(msg, "TX", cachep->ptt, 0);
} }
else // VFOB must be active so always RX or TX 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 msg[8192]; // could be pretty big
char buf[4096]; char buf[4096];
struct rig_cache *cachep = CACHE(rig);
// sprintf(msg,"%s:f=%.1f", date_strget(msg, (int)sizeof(msg), 0), f); // sprintf(msg,"%s:f=%.1f", date_strget(msg, (int)sizeof(msg), 0), f);
msg[0] = 0; msg[0] = 0;
snprintf(buf, sizeof(buf), "%s:%s", rig->caps->model_name, 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_time(msg, 1);
json_add_int(msg, "Sequence", rig->state.multicast->seqnumber++, 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_string(msg, "VFOCurr", rig_strvfo(rig->state.current_vfo), 1);
json_add_int(msg, "PTT", rig->state.cache.ptt, 1); json_add_int(msg, "PTT", cachep->ptt, 1);
json_add_int(msg, "Split", rig->state.cache.split, 1); json_add_int(msg, "Split", cachep->split, 1);
rig_sprintf_mode(buf, sizeof(buf), rig->state.mode_list); rig_sprintf_mode(buf, sizeof(buf), rig->state.mode_list);
json_add_string(msg, "ModeList", buf, 1); json_add_string(msg, "ModeList", buf, 1);
strcat(msg, "\"VFOs\": [\n"); strcat(msg, "\"VFOs\": [\n");
@ -369,6 +376,8 @@ void *multicast_thread(void *vrig)
mode_t modeA, modeAsave = 0; mode_t modeA, modeAsave = 0;
mode_t modeB, modeBsave = 0; mode_t modeB, modeBsave = 0;
ptt_t ptt, pttsave = 0; ptt_t ptt, pttsave = 0;
struct rig_cache *cachep = CACHE(rig);
rig->state.multicast->runflag = 1; rig->state.multicast->runflag = 1;
while (rig->state.multicast->runflag) while (rig->state.multicast->runflag)
@ -387,15 +396,15 @@ void *multicast_thread(void *vrig)
} }
else else
{ {
freqB = rig->state.cache.freqMainB; freqB = cachep->freqMainB;
} }
#else #else
freqA = rig->state.cache.freqMainA; freqA = cachep->freqMainA;
freqB = rig->state.cache.freqMainB; freqB = cachep->freqMainB;
modeA = rig->state.cache.modeMainA; modeA = cachep->modeMainA;
modeB = rig->state.cache.modeMainB; modeB = cachep->modeMainB;
ptt = rig->state.cache.ptt; ptt = cachep->ptt;
#endif #endif
if (freqA != freqAsave 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; cJSON *node;
char buf[1024]; char buf[1024];
struct rig_cache *cachep = CACHE(rig);
cJSON *id_node = cJSON_CreateObject(); cJSON *id_node = cJSON_CreateObject();
cJSON_AddStringToObject(id_node, "model", rig->caps->model_name); 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", 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) if (node == NULL)
{ {
@ -59,7 +60,7 @@ static int snapshot_serialize_rig(cJSON *rig_node, RIG *rig)
} }
node = cJSON_AddStringToObject(rig_node, "splitVfo", node = cJSON_AddStringToObject(rig_node, "splitVfo",
rig_strvfo(rig->state.cache.split_vfo)); rig_strvfo(cachep->split_vfo));
if (node == NULL) if (node == NULL)
{ {
@ -67,7 +68,7 @@ static int snapshot_serialize_rig(cJSON *rig_node, RIG *rig)
} }
node = cJSON_AddBoolToObject(rig_node, "satMode", node = cJSON_AddBoolToObject(rig_node, "satMode",
rig->state.cache.satmode ? 1 : 0); cachep->satmode ? 1 : 0);
if (node == NULL) if (node == NULL)
{ {
@ -111,6 +112,7 @@ static int snapshot_serialize_vfo(cJSON *vfo_node, RIG *rig, vfo_t vfo)
int result; int result;
int is_rx, is_tx; int is_rx, is_tx;
cJSON *node; cJSON *node;
struct rig_cache *cachep = CACHE(rig);
// TODO: This data should match rig_get_info command response // 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 = cachep->split;
split_vfo = rig->state.cache.split_vfo; split_vfo = cachep->split_vfo;
is_rx = (split == RIG_SPLIT_OFF && vfo == rig->state.current_vfo) is_rx = (split == RIG_SPLIT_OFF && vfo == rig->state.current_vfo)
|| (split == RIG_SPLIT_ON && vfo != split_vfo); || (split == RIG_SPLIT_ON && vfo != split_vfo);
is_tx = (split == RIG_SPLIT_OFF && vfo == rig->state.current_vfo) is_tx = (split == RIG_SPLIT_OFF && vfo == rig->state.current_vfo)
|| (split == RIG_SPLIT_ON && vfo == split_vfo); || (split == RIG_SPLIT_ON && vfo == split_vfo);
ptt = rig->state.cache.ptt && is_tx; ptt = cachep->ptt && is_tx;
if (is_tx) if (is_tx)
{ {