[Hamlib-commits] Hamlib -- Ham radio control libraries branch master updated. df64af4583a6e8fcac049
Library to control radio transceivers and receivers
Brought to you by:
n0nb
Menu
▾
▴
[Hamlib-commits] Hamlib -- Ham radio control libraries branch master updated. df64af4583a6e8fcac0494cd64a958ebb55ceff1
|
From: n0nb <n0...@us...> - 2024-01-16 13:26:57
|
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "Hamlib -- Ham radio control libraries".
The branch, master has been updated
via df64af4583a6e8fcac0494cd64a958ebb55ceff1 (commit)
via 0e5d2cfc481e209624e8d9858f7129067c3be179 (commit)
via 4d568c782e5e296f9d46e05fe8526de46f4fc51e (commit)
via d6689145a048ad34bd91904186df93b4fc39b7aa (commit)
via 34ccdcc5a57d7f06ebf6394fa50a94078b16e6ed (commit)
via f15679f5758653ff2f0f09aeefea3eecc76d6afe (commit)
via 7f6736368701d01944fb4f752e31099f9b0ff67e (commit)
via 64f69421de9f72cb8707b87915dbbb82add28ecf (commit)
via aa9c3b39baf9249e8bc3c8449971daa0cf4ea864 (commit)
via fddddf1f6f1a2acfa38a92ff6ef467eeda7b4bea (commit)
via 2c85a963092d4dd66bf6982a76dcc3c41ad70efe (commit)
via b0d1eb297f009eef57d1d5bb47055897c22ab224 (commit)
via cd1f4d39290b698e1db39f7deb055ad47de5cd89 (commit)
via e178a984ca693750f2b8a45f3e6b1e516faed281 (commit)
via 0b67958751067fc42a41a3ee6a734cbc70f5b4c2 (commit)
via 4b03abbdac27fabb8d084c0331a5810775438699 (commit)
via 11b5da878283f428144bbb21612dacc19fcd0a23 (commit)
via 190747430f6b6bd7b9283175d3fccb85057b0c28 (commit)
via f8fd79442dcc28a3c3ea1c7494754c8c8ff5baee (commit)
via 34f953ba0b04f25475d427a799b1f8b08eae40a3 (commit)
via 9b817f325df21e52416416aad431f50c6e9d770a (commit)
via dc0fd2955ddc7a2eb3bd9419e2ac3135aade0255 (commit)
via 89876895de0643f2ba050bed623f60ef2e96a786 (commit)
via 79c496800e1b5d15b497b057840047eea7705e05 (commit)
via a6951c8e1485df9ac2c71aad03bd7987f566d88a (commit)
via 2646f0fd3a18938dcac26a3e843774dd01740a9e (commit)
via 8280748acee945b084f740f1430903b4d42fd838 (commit)
via 32ed2c4d919be757e8616f3745ef8d668b9f09c9 (commit)
via ac054e9f75f8b9779346878eef3fcf2b7e33feaa (commit)
via 05fb4389f79280fb5f6198688d6c4cc58625245b (commit)
via e25fab7d2f279b6c8fb36775c16e5347fa7fc5ef (commit)
via ddb0a6427286cb8ee020ad4e1181e5ad6d42f76a (commit)
via 47062cf812ecda243266e40f7e8932966a236e7e (commit)
via 7002ca9f092b319a9e4643fb786efd714a0e182e (commit)
via a7d2a5e32b5084f584dccd07488c4e3082fb3238 (commit)
via 2709fb8ab9fdf5e8f24db7052d7d871381490eaa (commit)
via e610d3b691328e38302a20b451b813b477a10c3f (commit)
via cb74453f06e4d3955281c52ebe88f99c122dcf9c (commit)
via 5e59a555d8e605201b167c8b987613b43dbcd13c (commit)
via df78960ff1df985c512c7fbd2af36cd8b7e819e5 (commit)
via 8dff750285e43281511d4955813116418d22421f (commit)
via 9af715d2443f56b11862d34ddb56d8ccdbc48fb4 (commit)
via b38014832f36f4d901761829d13fae669a17acd7 (commit)
via 9c7a21282cef499e61a16513619a45b5860d2aac (commit)
from 21c14da270d8d73b9ecfffbf4c7709d6dc4f8c32 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit df64af4583a6e8fcac0494cd64a958ebb55ceff1
Author: Mike Black W9MDB <mdb...@ya...>
Date: Mon Jan 15 11:18:46 2024 -0600
Suppress no get_vfo message for Icom rigs.
No hope of getting Icom to ever provide this ability
diff --git a/src/rig.c b/src/rig.c
index 85adb1bcb..c1cfd970d 100644
--- a/src/rig.c
+++ b/src/rig.c
@@ -3329,7 +3329,7 @@ int HAMLIB_API rig_get_vfo(RIG *rig, vfo_t *vfo)
caps = rig->caps;
- if (caps->get_vfo == NULL)
+ if (caps->get_vfo == NULL && RIG_ICOM != RIG_BACKEND_NUM(rig->caps->rig_model))
{
rig_debug(RIG_DEBUG_WARN, "%s: no get_vfo\n", __func__);
ELAPSED2;
commit 0e5d2cfc481e209624e8d9858f7129067c3be179
Author: Mike Black W9MDB <mdb...@ya...>
Date: Mon Jan 15 07:33:21 2024 -0600
Fix tx_vfo default in rig.c
diff --git a/src/rig.c b/src/rig.c
index e280dbec3..85adb1bcb 100644
--- a/src/rig.c
+++ b/src/rig.c
@@ -4509,7 +4509,7 @@ int HAMLIB_API rig_set_split_freq(RIG *rig, vfo_t vfo, freq_t tx_freq)
{
const struct rig_caps *caps;
int retcode, rc2;
- vfo_t curr_vfo, tx_vfo;
+ vfo_t curr_vfo, tx_vfo = RIG_VFO_CURR;
freq_t tfreq = 0;
if (CHECK_RIG_ARG(rig))
commit 4d568c782e5e296f9d46e05fe8526de46f4fc51e
Author: Mike Black W9MDB <mdb...@ya...>
Date: Mon Jan 15 07:28:22 2024 -0600
Speed up rig_band_changed actions for FT991 and perhaps others
Putting the AC001; command immediately after FA freq change make the band change end state occur immediately
diff --git a/src/rig.c b/src/rig.c
index 8c395be28..e280dbec3 100644
--- a/src/rig.c
+++ b/src/rig.c
@@ -588,7 +588,7 @@ RIG *HAMLIB_API rig_init(rig_model_t rig_model)
rp = RIGPORT(rig);
pttp = PTTPORT(rig);
dcdp = DCDPORT(rig);
-
+
rs->rig_model = caps->rig_model;
rs->priv = NULL;
rs->async_data_enabled = 0;
@@ -1310,7 +1310,7 @@ int HAMLIB_API rig_open(RIG *rig)
case RIG_DCD_GPIO:
case RIG_DCD_GPION:
dcdp->fd = gpio_open(dcdp, 0,
- RIG_DCD_GPION == dcdp->type.dcd ? 0 : 1);
+ RIG_DCD_GPION == dcdp->type.dcd ? 0 : 1);
if (dcdp->fd < 0)
{
@@ -1977,6 +1977,7 @@ int rig_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
vfo_t vfo_save;
static int last_band = -1;
int curr_band;
+ int band_changing = 0;
if (CHECK_RIG_ARG(rig))
{
@@ -1990,7 +1991,8 @@ int rig_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
{
rig_debug(RIG_DEBUG_VERBOSE, "%s: band changing to %s\n", __func__,
rig_get_band_str(rig, curr_band, 0));
- rig_band_changed(rig, curr_band);
+ band_changing = 1;
+ //rig_band_changed(rig, curr_band);
last_band = curr_band;
}
@@ -2117,8 +2119,13 @@ int rig_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
do
{
- HAMLIB_TRACE;
retcode = caps->set_freq(rig, vfo, freq);
+
+ if (band_changing)
+ {
+ rig_band_changed(rig, curr_band);
+ }
+
// disabling the freq check as of 2023-06-02
// seems unnecessary and slows down rigs unnecessarily
tfreq = freq;
@@ -2207,6 +2214,9 @@ int rig_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
}
HAMLIB_TRACE;
+
+ if (band_changing) { rig_band_changed(rig, curr_band); }
+
retcode = caps->set_freq(rig, vfo, freq);
}
@@ -4521,10 +4531,8 @@ int HAMLIB_API rig_set_split_freq(RIG *rig, vfo_t vfo, freq_t tx_freq)
{
tx_vfo = rig->state.tx_vfo;
}
- else
- {
- tx_vfo = vfo_fixup(rig, vfo, rig->state.cache.split);
- }
+
+ tx_vfo = vfo_fixup(rig, tx_vfo, rig->state.cache.split);
rig_get_freq(rig, tx_vfo, &tfreq);
@@ -8652,18 +8660,22 @@ int morse_data_handler_set_keyspd(RIG *rig, int keyspd)
*/
HAMLIB_EXPORT(void *) rig_data_pointer(RIG *rig, rig_ptrx_t idx)
{
- switch(idx)
+ switch (idx)
{
case RIG_PTRX_RIGPORT:
- return RIGPORT(rig);
+ return RIGPORT(rig);
+
case RIG_PTRX_PTTPORT:
- return PTTPORT(rig);
+ return PTTPORT(rig);
+
case RIG_PTRX_DCDPORT:
- return DCDPORT(rig);
+ return DCDPORT(rig);
+
case RIG_PTRX_CACHE:
- return CACHE(rig);
+ return CACHE(rig);
+
default:
- rig_debug(RIG_DEBUG_ERR, "%s: Invalid data index=%d\n", __func__, idx);
- return NULL;
+ rig_debug(RIG_DEBUG_ERR, "%s: Invalid data index=%d\n", __func__, idx);
+ return NULL;
}
}
commit d6689145a048ad34bd91904186df93b4fc39b7aa
Author: Mike Black W9MDB <mdb...@ya...>
Date: Sun Jan 14 23:06:41 2024 -0600
Make rig_band_changed HAMLIB_API
diff --git a/src/band_changed.c b/src/band_changed.c
index 075f46ce2..848bef0bb 100644
--- a/src/band_changed.c
+++ b/src/band_changed.c
@@ -2,7 +2,7 @@
// Can customize during build
// Eventually should improved this for external actions when
// rigctld gets integrated as a service within Hamlib
-int rig_band_changed(RIG *rig, hamlib_bandselect_t band)
+int HAMLIB_API rig_band_changed(RIG *rig, hamlib_bandselect_t band)
{
// See band_changed.c
// Examples:
commit 34ccdcc5a57d7f06ebf6394fa50a94078b16e6ed
Merge: 0b6795875 f15679f57
Author: Michael Black <mdb...@ya...>
Date: Sun Jan 14 22:24:48 2024 -0600
Merge pull request #1476 from GeoBaltz/rp2
Phase 2 of moving port structures
commit f15679f5758653ff2f0f09aeefea3eecc76d6afe
Author: George Baltz N3GB <Geo...@gm...>
Date: Sun Jan 14 16:50:06 2024 -0500
Update example.c
Avoid using raw rigport, in two different ways.
Fix variable name.
diff --git a/tests/example.c b/tests/example.c
index c784c3698..a9274d3c0 100644
--- a/tests/example.c
+++ b/tests/example.c
@@ -43,9 +43,9 @@ int main()
/* Instantiate a rig */
my_rig = rig_init(MODEL); // your rig model.
- strncpy(my_rig->state.rigport.pathname, PATH, HAMLIB_FILPATHLEN - 1);
+ rig_set_conf(my_rig, rig_token_lookup(my_rig, "rig_pathname"), PATH);
- my_rig->state.rigport.parm.serial.rate = BAUD; // your baud rate
+ HAMLIB_RIGPORT(my_rig)->parm.serial.rate = BAUD; // your baud rate
/* Open my rig */
retcode = rig_open(my_rig);
@@ -131,7 +131,7 @@ int main()
if (range)
{
char vfolist[256];
- rig_sprintf_vfo(vfolist, sizeof(vfo_list), my_rig->state.vfo_list);
+ rig_sprintf_vfo(vfolist, sizeof(vfolist), my_rig->state.vfo_list);
printf("Range start=%"PRIfreq", end=%"PRIfreq", low_power=%d, high_power=%d, vfos=%s\n",
range->startf, range->endf, range->low_power, range->high_power, vfolist);
}
commit 7f6736368701d01944fb4f752e31099f9b0ff67e
Author: George Baltz N3GB <Geo...@gm...>
Date: Sun Jan 14 15:08:18 2024 -0500
Need more parens to work in expressions.
Clean up sticky note items.
diff --git a/include/hamlib/rig.h b/include/hamlib/rig.h
index f4760ed68..4a48d1c04 100644
--- a/include/hamlib/rig.h
+++ b/include/hamlib/rig.h
@@ -2489,13 +2489,13 @@ typedef hamlib_port_t port_t;
*/
#else
/* Define external unique names */
-#define HAMLIB_RIGPORT(r) (hamlib_port_t *)rig_data_pointer(r, RIG_PTRX_RIGPORT)
-#define HAMLIB_PTTPORT(r) (hamlib_port_t *)rig_data_pointer(r, RIG_PTRX_PTTPORT)
-#define HAMLIB_DCDPORT(r) (hamlib_port_t *)rig_data_pointer(r, RIG_PTRX_DCDPORT)
-//#define HAMLIB_CACHE(r) (struct rig_cache *)rig_data_pointer(r, RIG_PTRX_CACHE)
-#define HAMLIB_AMPPORT(a) (hamlib_port_t *)amp_data_pointer(a, RIG_PTRX_AMPPORT)
-#define HAMLIB_ROTPORT(r) (hamlib_port_t *)rot_data_pointer(r, RIG_PTRX_ROTPORT)
-#define HAMLIB_ROTPORT2(r) (hamlib_port_t *)rot_data_pointer(r, RIG_PTRX_ROTPORT2)
+#define HAMLIB_RIGPORT(r) ((hamlib_port_t *)rig_data_pointer(r, RIG_PTRX_RIGPORT))
+#define HAMLIB_PTTPORT(r) ((hamlib_port_t *)rig_data_pointer(r, RIG_PTRX_PTTPORT))
+#define HAMLIB_DCDPORT(r) ((hamlib_port_t *)rig_data_pointer(r, RIG_PTRX_DCDPORT))
+#define HAMLIB_CACHE(r) ((struct rig_cache *)rig_data_pointer(r, RIG_PTRX_CACHE))
+#define HAMLIB_AMPPORT(a) ((hamlib_port_t *)amp_data_pointer(a, RIG_PTRX_AMPPORT))
+#define HAMLIB_ROTPORT(r) ((hamlib_port_t *)rot_data_pointer(r, RIG_PTRX_ROTPORT))
+#define HAMLIB_ROTPORT2(r) ((hamlib_port_t *)rot_data_pointer(r, RIG_PTRX_ROTPORT2))
#endif
typedef enum {
diff --git a/src/conf.c b/src/conf.c
index 7a37428a3..5099a0fad 100644
--- a/src/conf.c
+++ b/src/conf.c
@@ -573,7 +573,7 @@ static int frontend_set_conf(RIG *rig, token_t token, const char *val)
}
// JTDX and WSJTX currently use state.pttport to check for PTT_NONE
- rig->state.pttport.type.ptt = pttp->type.ptt;
+// rig->state.pttport.type.ptt = pttp->type.ptt;
rs->pttport_deprecated.type.ptt = pttp->type.ptt;
break;
commit 64f69421de9f72cb8707b87915dbbb82add28ecf
Author: George Baltz N3GB <Geo...@gm...>
Date: Sat Jan 13 20:55:27 2024 -0500
Pointerize all the ports in src/rig.c
diff --git a/src/rig.c b/src/rig.c
index a3c93396f..8c395be28 100644
--- a/src/rig.c
+++ b/src/rig.c
@@ -518,6 +518,7 @@ RIG *HAMLIB_API rig_init(rig_model_t rig_model)
RIG *rig;
const struct rig_caps *caps;
struct rig_state *rs;
+ hamlib_port_t *rp, *pttp, *dcdp;
int i;
rig_check_rig_caps();
@@ -582,11 +583,17 @@ RIG *HAMLIB_API rig_init(rig_model_t rig_model)
pthread_mutex_init(&rs->mutex_set_transaction, NULL);
#endif
+ //TODO Allocate and link ports
+ // For now, use the embedded ones
+ rp = RIGPORT(rig);
+ pttp = PTTPORT(rig);
+ dcdp = DCDPORT(rig);
+
rs->rig_model = caps->rig_model;
rs->priv = NULL;
rs->async_data_enabled = 0;
- rs->rigport.fd = -1;
- rs->pttport.fd = -1;
+ rp->fd = -1;
+ pttp->fd = -1;
rs->comm_state = 0;
rig->state.depth = 1;
#if 0 // extra debug if needed
@@ -594,9 +601,9 @@ RIG *HAMLIB_API rig_init(rig_model_t rig_model)
__LINE__, &rs->comm_state,
rs->comm_state);
#endif
- rs->rigport.type.rig = caps->port_type; /* default from caps */
+ rp->type.rig = caps->port_type; /* default from caps */
#if defined(HAVE_PTHREAD)
- rs->rigport.asyncio = 0;
+ rp->asyncio = 0;
#endif
rig->state.comm_status = RIG_COMM_STATUS_CONNECTING;
@@ -605,73 +612,73 @@ RIG *HAMLIB_API rig_init(rig_model_t rig_model)
switch (caps->port_type)
{
case RIG_PORT_SERIAL:
- strncpy(rs->rigport.pathname, DEFAULT_SERIAL_PORT, HAMLIB_FILPATHLEN - 1);
- rs->rigport.parm.serial.rate = caps->serial_rate_max; /* fastest ! */
- rs->rigport.parm.serial.data_bits = caps->serial_data_bits;
- rs->rigport.parm.serial.stop_bits = caps->serial_stop_bits;
- rs->rigport.parm.serial.parity = caps->serial_parity;
- rs->rigport.parm.serial.handshake = caps->serial_handshake;
+ strncpy(rp->pathname, DEFAULT_SERIAL_PORT, HAMLIB_FILPATHLEN - 1);
+ rp->parm.serial.rate = caps->serial_rate_max; /* fastest ! */
+ rp->parm.serial.data_bits = caps->serial_data_bits;
+ rp->parm.serial.stop_bits = caps->serial_stop_bits;
+ rp->parm.serial.parity = caps->serial_parity;
+ rp->parm.serial.handshake = caps->serial_handshake;
break;
case RIG_PORT_PARALLEL:
- strncpy(rs->rigport.pathname, DEFAULT_PARALLEL_PORT, HAMLIB_FILPATHLEN - 1);
+ strncpy(rp->pathname, DEFAULT_PARALLEL_PORT, HAMLIB_FILPATHLEN - 1);
break;
/* Adding support for CM108 GPIO. This is compatible with CM108 series
* USB audio chips from CMedia and SSS1623 series USB audio chips from 3S
*/
case RIG_PORT_CM108:
- strncpy(rs->rigport.pathname, DEFAULT_CM108_PORT, HAMLIB_FILPATHLEN);
+ strncpy(rp->pathname, DEFAULT_CM108_PORT, HAMLIB_FILPATHLEN);
- if (rs->rigport.parm.cm108.ptt_bitnum == 0)
+ if (rp->parm.cm108.ptt_bitnum == 0)
{
- rs->rigport.parm.cm108.ptt_bitnum = DEFAULT_CM108_PTT_BITNUM;
- rs->pttport.parm.cm108.ptt_bitnum = DEFAULT_CM108_PTT_BITNUM;
+ rp->parm.cm108.ptt_bitnum = DEFAULT_CM108_PTT_BITNUM;
+ pttp->parm.cm108.ptt_bitnum = DEFAULT_CM108_PTT_BITNUM;
}
break;
case RIG_PORT_GPIO:
- strncpy(rs->rigport.pathname, DEFAULT_GPIO_PORT, HAMLIB_FILPATHLEN);
+ strncpy(rp->pathname, DEFAULT_GPIO_PORT, HAMLIB_FILPATHLEN);
break;
case RIG_PORT_NETWORK:
case RIG_PORT_UDP_NETWORK:
- strncpy(rs->rigport.pathname, "127.0.0.1:4532", HAMLIB_FILPATHLEN - 1);
+ strncpy(rp->pathname, "127.0.0.1:4532", HAMLIB_FILPATHLEN - 1);
break;
default:
- strncpy(rs->rigport.pathname, "", HAMLIB_FILPATHLEN - 1);
+ strncpy(rp->pathname, "", HAMLIB_FILPATHLEN - 1);
}
- rs->rigport.write_delay = caps->write_delay;
- rs->rigport.post_write_delay = caps->post_write_delay;
+ rp->write_delay = caps->write_delay;
+ rp->post_write_delay = caps->post_write_delay;
// since we do two timeouts now we can cut the timeout in half for serial
if (caps->port_type == RIG_PORT_SERIAL && caps->timeout_retry >= 0)
{
- rs->rigport.timeout = caps->timeout / 2;
+ rp->timeout = caps->timeout / 2;
}
- rs->rigport.retry = caps->retry;
+ rp->retry = caps->retry;
if (caps->timeout_retry < 0)
{
// Rigs may disable read timeout retries
- rs->rigport.timeout_retry = 0;
+ rp->timeout_retry = 0;
}
else if (caps->timeout_retry == 0)
{
// Default to 1 retry for read timeouts
- rs->rigport.timeout_retry = 1;
+ rp->timeout_retry = 1;
}
else
{
- rs->rigport.timeout_retry = caps->timeout_retry;
+ rp->timeout_retry = caps->timeout_retry;
}
- rs->pttport.type.ptt = caps->ptt_type;
- rs->dcdport.type.dcd = caps->dcd_type;
+ pttp->type.ptt = caps->ptt_type;
+ dcdp->type.dcd = caps->dcd_type;
rs->vfo_comp = 0.0; /* override it with preferences */
rs->current_vfo = RIG_VFO_CURR; /* we don't know yet! */
@@ -837,7 +844,7 @@ RIG *HAMLIB_API rig_init(rig_model_t rig_model)
rs->max_ifshift = caps->max_ifshift;
rs->announces = caps->announces;
- rs->rigport.fd = rs->pttport.fd = rs->dcdport.fd = -1;
+ rp->fd = pttp->fd = dcdp->fd = -1;
// some rigs (like SDR) behave differnt when checking for power on
// So we assume power is on until one of the backends KNOWS it is off
rs->powerstat = RIG_POWER_ON; // default to power on until proven otherwise
@@ -889,6 +896,9 @@ int HAMLIB_API rig_open(RIG *rig)
{
struct rig_caps *caps;
struct rig_state *rs;
+ hamlib_port_t *rp = RIGPORT(rig);
+ hamlib_port_t *pttp = PTTPORT(rig);
+ hamlib_port_t *dcdp = DCDPORT(rig);
int status = RIG_OK;
value_t parm_value;
//unsigned int net1, net2, net3, net4, net5, net6, net7, net8, port;
@@ -904,10 +914,10 @@ int HAMLIB_API rig_open(RIG *rig)
caps = rig->caps;
rs = &rig->state;
- rs->rigport.rig = rig;
+ rp->rig = rig;
rs->rigport_deprecated.rig = rig;
- if (strcmp(rs->rigport.pathname, "USB") == 0)
+ if (strcmp(rp->pathname, "USB") == 0)
{
rig_debug(RIG_DEBUG_ERR, "%s: 'USB' is not a valid COM port name\n", __func__);
errno = 2;
@@ -917,27 +927,27 @@ int HAMLIB_API rig_open(RIG *rig)
// rigctl/rigctld may have deprecated values -- backwards compatibility
if (rs->rigport_deprecated.pathname[0] != 0)
{
- strcpy(rs->rigport.pathname, rs->rigport_deprecated.pathname);
+ strcpy(rp->pathname, rs->rigport_deprecated.pathname);
}
if (rs->pttport_deprecated.type.ptt != RIG_PTT_NONE)
{
- rs->pttport.type.ptt = rs->pttport_deprecated.type.ptt;
+ pttp->type.ptt = rs->pttport_deprecated.type.ptt;
}
if (rs->dcdport_deprecated.type.dcd != RIG_DCD_NONE)
{
- rs->dcdport.type.dcd = rs->dcdport_deprecated.type.dcd;
+ dcdp->type.dcd = rs->dcdport_deprecated.type.dcd;
}
if (rs->pttport_deprecated.pathname[0] != 0)
{
- strcpy(rs->pttport.pathname, rs->pttport_deprecated.pathname);
+ strcpy(pttp->pathname, rs->pttport_deprecated.pathname);
}
if (rs->dcdport_deprecated.pathname[0] != 0)
{
- strcpy(rs->dcdport.pathname, rs->dcdport_deprecated.pathname);
+ strcpy(dcdp->pathname, rs->dcdport_deprecated.pathname);
}
rig_settings_load_all(NULL); // load default .hamlib_settings
@@ -987,12 +997,12 @@ int HAMLIB_API rig_open(RIG *rig)
"%s: async_data_enable=%d, async_data_supported=%d\n", __func__,
rs->async_data_enabled, caps->async_data_supported);
rs->async_data_enabled = rs->async_data_enabled && caps->async_data_supported;
- rs->rigport.asyncio = rs->async_data_enabled;
+ rp->asyncio = rs->async_data_enabled;
- if (strlen(rs->rigport.pathname) > 0)
+ if (strlen(rp->pathname) > 0)
{
char hoststr[256], portstr[6];
- status = parse_hoststr(rs->rigport.pathname, sizeof(rs->rigport.pathname),
+ status = parse_hoststr(rp->pathname, sizeof(rp->pathname),
hoststr, portstr);
if (status == RIG_OK) { is_network = 1; }
@@ -1001,16 +1011,16 @@ int HAMLIB_API rig_open(RIG *rig)
#if 0
// determine if we have a network address
//
- is_network |= sscanf(rs->rigport.pathname, "%u.%u.%u.%u:%u", &net1, &net2,
+ is_network |= sscanf(rp->pathname, "%u.%u.%u.%u:%u", &net1, &net2,
&net3, &net4, &port) == 5;
- is_network |= sscanf(rs->rigport.pathname, ":%u", &port) == 1;
- is_network |= sscanf(rs->rigport.pathname, "%u::%u:%u:%u:%u:%u", &net1, &net2,
+ is_network |= sscanf(rp->pathname, ":%u", &port) == 1;
+ is_network |= sscanf(rp->pathname, "%u::%u:%u:%u:%u:%u", &net1, &net2,
&net3, &net4, &net5, &port) == 6;
- is_network |= sscanf(rs->rigport.pathname, "%u:%u:%u:%u:%u:%u:%u:%u:%u", &net1,
+ is_network |= sscanf(rp->pathname, "%u:%u:%u:%u:%u:%u:%u:%u:%u", &net1,
&net2, &net3, &net4, &net5, &net6, &net7, &net8, &port) == 9;
// if we haven't met one of the condition above then we must have a hostname
- if (!is_network && (token = strtok_r(rs->rigport.pathname, ":", &strtokp)))
+ if (!is_network && (token = strtok_r(rp->pathname, ":", &strtokp)))
{
rig_debug(RIG_DEBUG_TRACE, "%s: token1=%s\n", __func__, token);
token = strtok_r(strtokp, ":", &strtokp);
@@ -1028,8 +1038,8 @@ int HAMLIB_API rig_open(RIG *rig)
if (is_network)
{
rig_debug(RIG_DEBUG_TRACE, "%s: using network address %s\n", __func__,
- rs->rigport.pathname);
- rs->rigport.type.rig = RIG_PORT_NETWORK;
+ rp->pathname);
+ rp->type.rig = RIG_PORT_NETWORK;
if (RIG_BACKEND_NUM(rig->caps->rig_model) == RIG_ICOM)
{
@@ -1039,7 +1049,7 @@ int HAMLIB_API rig_open(RIG *rig)
{
rig_debug(RIG_DEBUG_TRACE, "%s(%d): Icom rig UDP network enabled\n", __FILE__,
__LINE__);
- rs->rigport.type.rig = RIG_PORT_UDP_NETWORK;
+ rp->type.rig = RIG_PORT_UDP_NETWORK;
}
#endif
@@ -1051,55 +1061,55 @@ int HAMLIB_API rig_open(RIG *rig)
rig_debug(RIG_DEBUG_VERBOSE, "%s(%d): %p rs->comm_state==1?=%d\n", __func__,
__LINE__, &rs->comm_state,
rs->comm_state);
- port_close(&rs->rigport, rs->rigport.type.rig);
+ port_close(rp, rp->type.rig);
rs->comm_state = 0;
RETURNFUNC2(-RIG_EINVAL);
}
rs->comm_status = RIG_COMM_STATUS_CONNECTING;
- rs->rigport.fd = -1;
+ rp->fd = -1;
- if (rs->rigport.type.rig == RIG_PORT_SERIAL)
+ if (rp->type.rig == RIG_PORT_SERIAL)
{
- if (rs->rigport.parm.serial.rts_state != RIG_SIGNAL_UNSET
- && rs->rigport.parm.serial.handshake == RIG_HANDSHAKE_HARDWARE)
+ if (rp->parm.serial.rts_state != RIG_SIGNAL_UNSET
+ && rp->parm.serial.handshake == RIG_HANDSHAKE_HARDWARE)
{
rig_debug(RIG_DEBUG_ERR,
"%s: cannot set RTS with hardware handshake \"%s\"\n",
__func__,
- rs->rigport.pathname);
+ rp->pathname);
RETURNFUNC2(-RIG_ECONF);
}
- if ('\0' == rs->pttport.pathname[0]
- || !strcmp(rs->pttport.pathname, rs->rigport.pathname))
+ if ('\0' == pttp->pathname[0]
+ || !strcmp(pttp->pathname, rp->pathname))
{
/* check for control line conflicts */
- if (rs->rigport.parm.serial.rts_state != RIG_SIGNAL_UNSET
- && rs->pttport.type.ptt == RIG_PTT_SERIAL_RTS)
+ if (rp->parm.serial.rts_state != RIG_SIGNAL_UNSET
+ && pttp->type.ptt == RIG_PTT_SERIAL_RTS)
{
rig_debug(RIG_DEBUG_ERR,
"%s: cannot set RTS with PTT by RTS \"%s\"\n",
__func__,
- rs->rigport.pathname);
+ rp->pathname);
RETURNFUNC2(-RIG_ECONF);
}
- if (rs->rigport.parm.serial.dtr_state != RIG_SIGNAL_UNSET
- && rs->pttport.type.ptt == RIG_PTT_SERIAL_DTR)
+ if (rp->parm.serial.dtr_state != RIG_SIGNAL_UNSET
+ && pttp->type.ptt == RIG_PTT_SERIAL_DTR)
{
rig_debug(RIG_DEBUG_ERR,
"%s: cannot set DTR with PTT by DTR \"%s\"\n",
__func__,
- rs->rigport.pathname);
+ rp->pathname);
RETURNFUNC2(-RIG_ECONF);
}
}
}
- rs->rigport.timeout = caps->timeout;
- status = port_open(&rs->rigport);
+ rp->timeout = caps->timeout;
+ status = port_open(rp);
if (status < 0)
{
@@ -1110,7 +1120,7 @@ int HAMLIB_API rig_open(RIG *rig)
RETURNFUNC2(status);
}
- switch (rs->pttport.type.ptt)
+ switch (pttp->type.ptt)
{
case RIG_PTT_NONE:
case RIG_PTT_RIG:
@@ -1119,124 +1129,123 @@ int HAMLIB_API rig_open(RIG *rig)
case RIG_PTT_SERIAL_RTS:
case RIG_PTT_SERIAL_DTR:
- if (rs->pttport.pathname[0] == '\0'
- && rs->rigport.type.rig == RIG_PORT_SERIAL)
+ if (pttp->pathname[0] == '\0'
+ && rp->type.rig == RIG_PORT_SERIAL)
{
- strcpy(rs->pttport.pathname, rs->rigport.pathname);
+ strcpy(pttp->pathname, rp->pathname);
}
- if (!strcmp(rs->pttport.pathname, rs->rigport.pathname))
+ if (!strcmp(pttp->pathname, rp->pathname))
{
- rs->pttport.fd = rs->rigport.fd;
+ pttp->fd = rp->fd;
/* Needed on Linux because the serial port driver sets RTS/DTR
on open - only need to address the PTT line as we offer
config parameters to control the other (dtr_state &
rts_state) */
- if (rs->pttport.type.ptt == RIG_PTT_SERIAL_DTR)
+ if (pttp->type.ptt == RIG_PTT_SERIAL_DTR)
{
- status = ser_set_dtr(&rs->pttport, 0);
+ status = ser_set_dtr(pttp, 0);
}
- if (rs->pttport.type.ptt == RIG_PTT_SERIAL_RTS)
+ if (pttp->type.ptt == RIG_PTT_SERIAL_RTS)
{
- status = ser_set_rts(&rs->pttport, 0);
+ status = ser_set_rts(pttp, 0);
}
}
else
{
- rs->pttport.fd = ser_open(&rs->pttport);
+ pttp->fd = ser_open(pttp);
- if (rs->pttport.fd < 0)
+ if (pttp->fd < 0)
{
rig_debug(RIG_DEBUG_ERR,
"%s: cannot open PTT device \"%s\"\n",
__func__,
- rs->pttport.pathname);
+ pttp->pathname);
status = -RIG_EIO;
}
if (RIG_OK == status
- && (rs->pttport.type.ptt == RIG_PTT_SERIAL_DTR
- || rs->pttport.type.ptt == RIG_PTT_SERIAL_RTS))
+ && (pttp->type.ptt == RIG_PTT_SERIAL_DTR
+ || pttp->type.ptt == RIG_PTT_SERIAL_RTS))
{
/* Needed on Linux because the serial port driver sets
RTS/DTR high on open - set both low since we offer no
control of the non-PTT line and low is better than
high */
- status = ser_set_dtr(&rs->pttport, 0);
+ status = ser_set_dtr(pttp, 0);
if (RIG_OK == status)
{
- status = ser_set_rts(&rs->pttport, 0);
+ status = ser_set_rts(pttp, 0);
}
}
- ser_close(&rs->pttport);
+ ser_close(pttp);
}
break;
case RIG_PTT_PARALLEL:
- rs->pttport.fd = par_open(&rs->pttport);
+ pttp->fd = par_open(pttp);
- if (rs->pttport.fd < 0)
+ if (pttp->fd < 0)
{
rig_debug(RIG_DEBUG_ERR,
"%s: cannot open PTT device \"%s\"\n",
__func__,
- rs->pttport.pathname);
+ pttp->pathname);
status = -RIG_EIO;
}
else
{
- par_ptt_set(&rs->pttport, RIG_PTT_OFF);
+ par_ptt_set(pttp, RIG_PTT_OFF);
}
break;
case RIG_PTT_CM108:
- rs->pttport.fd = cm108_open(&rs->pttport);
+ pttp->fd = cm108_open(pttp);
- strncpy(rs->rigport.pathname, DEFAULT_CM108_PORT, HAMLIB_FILPATHLEN);
+ strncpy(rp->pathname, DEFAULT_CM108_PORT, HAMLIB_FILPATHLEN);
- if (rs->rigport.parm.cm108.ptt_bitnum == 0)
+ if (rp->parm.cm108.ptt_bitnum == 0)
{
- rs->rigport.parm.cm108.ptt_bitnum = DEFAULT_CM108_PTT_BITNUM;
- rs->pttport.parm.cm108.ptt_bitnum = DEFAULT_CM108_PTT_BITNUM;
+ rp->parm.cm108.ptt_bitnum = DEFAULT_CM108_PTT_BITNUM;
+ pttp->parm.cm108.ptt_bitnum = DEFAULT_CM108_PTT_BITNUM;
}
- if (rs->pttport.fd < 0)
+ if (pttp->fd < 0)
{
rig_debug(RIG_DEBUG_ERR,
"%s: cannot open PTT device \"%s\"\n",
__func__,
- rs->pttport.pathname);
+ pttp->pathname);
status = -RIG_EIO;
}
else
{
- cm108_ptt_set(&rs->pttport, RIG_PTT_OFF);
+ cm108_ptt_set(pttp, RIG_PTT_OFF);
}
break;
case RIG_PTT_GPIO:
case RIG_PTT_GPION:
- rs->pttport.fd = gpio_open(&rs->pttport, 1,
- RIG_PTT_GPION == rs->pttport.type.ptt ? 0 : 1);
+ pttp->fd = gpio_open(pttp, 1, RIG_PTT_GPION == pttp->type.ptt ? 0 : 1);
- if (rs->pttport.fd < 0)
+ if (pttp->fd < 0)
{
rig_debug(RIG_DEBUG_ERR,
"%s: cannot open PTT device \"GPIO%s\"\n",
__func__,
- rs->pttport.pathname);
+ pttp->pathname);
status = -RIG_EIO;
}
else
{
- gpio_ptt_set(&rs->pttport, RIG_PTT_OFF);
+ gpio_ptt_set(pttp, RIG_PTT_OFF);
}
break;
@@ -1245,11 +1254,11 @@ int HAMLIB_API rig_open(RIG *rig)
rig_debug(RIG_DEBUG_ERR,
"%s: unsupported PTT type %d\n",
__func__,
- rs->pttport.type.ptt);
+ pttp->type.ptt);
status = -RIG_ECONF;
}
- switch (rs->dcdport.type.dcd)
+ switch (dcdp->type.dcd)
{
case RIG_DCD_NONE:
case RIG_DCD_RIG:
@@ -1258,41 +1267,41 @@ int HAMLIB_API rig_open(RIG *rig)
case RIG_DCD_SERIAL_DSR:
case RIG_DCD_SERIAL_CTS:
case RIG_DCD_SERIAL_CAR:
- if (rs->dcdport.pathname[0] == '\0'
- && rs->rigport.type.rig == RIG_PORT_SERIAL)
+ if (dcdp->pathname[0] == '\0'
+ && rp->type.rig == RIG_PORT_SERIAL)
{
- strcpy(rs->dcdport.pathname, rs->rigport.pathname);
+ strcpy(dcdp->pathname, rp->pathname);
}
- if (strcmp(rs->dcdport.pathname, rs->rigport.pathname) == 0)
+ if (strcmp(dcdp->pathname, rp->pathname) == 0)
{
- rs->dcdport.fd = rs->rigport.fd;
+ dcdp->fd = rp->fd;
}
else
{
- rs->dcdport.fd = ser_open(&rs->dcdport);
+ dcdp->fd = ser_open(dcdp);
}
- if (rs->dcdport.fd < 0)
+ if (dcdp->fd < 0)
{
rig_debug(RIG_DEBUG_ERR,
"%s: cannot open DCD device \"%s\"\n",
__func__,
- rs->dcdport.pathname);
+ dcdp->pathname);
status = -RIG_EIO;
}
break;
case RIG_DCD_PARALLEL:
- rs->dcdport.fd = par_open(&rs->dcdport);
+ dcdp->fd = par_open(dcdp);
- if (rs->dcdport.fd < 0)
+ if (dcdp->fd < 0)
{
rig_debug(RIG_DEBUG_ERR,
"%s: cannot open DCD device \"%s\"\n",
__func__,
- rs->dcdport.pathname);
+ dcdp->pathname);
status = -RIG_EIO;
}
@@ -1300,15 +1309,15 @@ int HAMLIB_API rig_open(RIG *rig)
case RIG_DCD_GPIO:
case RIG_DCD_GPION:
- rs->dcdport.fd = gpio_open(&rs->dcdport, 0,
- RIG_DCD_GPION == rs->dcdport.type.dcd ? 0 : 1);
+ dcdp->fd = gpio_open(dcdp, 0,
+ RIG_DCD_GPION == dcdp->type.dcd ? 0 : 1);
- if (rs->dcdport.fd < 0)
+ if (dcdp->fd < 0)
{
rig_debug(RIG_DEBUG_ERR,
"%s: cannot open DCD device \"GPIO%s\"\n",
__func__,
- rs->dcdport.pathname);
+ dcdp->pathname);
status = -RIG_EIO;
}
@@ -1318,13 +1327,13 @@ int HAMLIB_API rig_open(RIG *rig)
rig_debug(RIG_DEBUG_ERR,
"%s: unsupported DCD type %d\n",
__func__,
- rs->dcdport.type.dcd);
+ dcdp->type.dcd);
status = -RIG_ECONF;
}
if (status < 0)
{
- port_close(&rs->rigport, rs->rigport.type.rig);
+ port_close(rp, rp->type.rig);
rig->state.comm_status = RIG_COMM_STATUS_ERROR;
RETURNFUNC2(status);
}
@@ -1337,7 +1346,7 @@ int HAMLIB_API rig_open(RIG *rig)
if (status < 0)
{
- port_close(&rs->rigport, rs->rigport.type.rig);
+ port_close(rp, rp->type.rig);
rig->state.comm_status = RIG_COMM_STATUS_ERROR;
RETURNFUNC2(status);
}
@@ -1357,8 +1366,8 @@ int HAMLIB_API rig_open(RIG *rig)
* Maybe the backend has something to initialize
* In case of failure, just close down and report error code.
*/
- int retry_save = rs->rigport.retry;
- rs->rigport.retry = 0;
+ int retry_save = rp->retry;
+ rp->retry = 0;
if (caps->rig_open != NULL)
{
@@ -1404,8 +1413,8 @@ int HAMLIB_API rig_open(RIG *rig)
}
#endif
- port_close(&rs->rigport, rs->rigport.type.rig);
- memcpy(&rs->rigport_deprecated, &rs->rigport, sizeof(hamlib_port_t_deprecated));
+ port_close(rp, rp->type.rig);
+ memcpy(&rs->rigport_deprecated, rp, sizeof(hamlib_port_t_deprecated));
rs->comm_state = 0;
rig->state.comm_status = RIG_COMM_STATUS_ERROR;
RETURNFUNC2(status);
@@ -1466,7 +1475,7 @@ int HAMLIB_API rig_open(RIG *rig)
{
rig_debug(RIG_DEBUG_ERR, "%s: cw_data_handler_start failed: %s\n", __func__,
rigerror(status));
- port_close(&rs->rigport, rs->rigport.type.rig);
+ port_close(rp, rp->type.rig);
RETURNFUNC2(status);
}
@@ -1535,12 +1544,12 @@ int HAMLIB_API rig_open(RIG *rig)
}
}
- rs->rigport.retry = retry_save;
+ rp->retry = retry_save;
- memcpy(&rs->rigport_deprecated, &rs->rigport, sizeof(hamlib_port_t_deprecated));
- memcpy(&rs->pttport_deprecated, &rs->pttport, sizeof(hamlib_port_t_deprecated));
- memcpy(&rs->dcdport_deprecated, &rs->dcdport, sizeof(hamlib_port_t_deprecated));
- rig_flush_force(&rs->rigport, 1);
+ memcpy(&rs->rigport_deprecated, rp, sizeof(hamlib_port_t_deprecated));
+ memcpy(&rs->pttport_deprecated, pttp, sizeof(hamlib_port_t_deprecated));
+ memcpy(&rs->dcdport_deprecated, dcdp, sizeof(hamlib_port_t_deprecated));
+ rig_flush_force(rp, 1);
#if defined(HAVE_PTHREAD)
enum multicast_item_e items = RIG_MULTICAST_POLL | RIG_MULTICAST_TRANSCEIVE
@@ -1602,6 +1611,9 @@ int HAMLIB_API rig_open(RIG *rig)
int HAMLIB_API rig_close(RIG *rig)
{
const struct rig_caps *caps;
+ hamlib_port_t *rp = RIGPORT(rig);
+ hamlib_port_t *pttp = PTTPORT(rig);
+ hamlib_port_t *dcdp = DCDPORT(rig);
struct rig_state *rs;
if (!rig || !rig->caps)
@@ -1652,7 +1664,7 @@ int HAMLIB_API rig_close(RIG *rig)
* FIXME: what happens if PTT and rig ports are the same?
* (eg. ptt_type = RIG_PTT_SERIAL)
*/
- switch (rs->pttport.type.ptt)
+ switch (pttp->type.ptt)
{
case RIG_PTT_NONE:
case RIG_PTT_RIG:
@@ -1662,14 +1674,14 @@ int HAMLIB_API rig_close(RIG *rig)
case RIG_PTT_SERIAL_RTS:
// If port is already closed, do nothing
- if (rs->pttport.fd > -1)
+ if (pttp->fd > -1)
{
- ser_set_rts(&rs->pttport, 0);
+ ser_set_rts(pttp, 0);
- if (rs->pttport.fd != rs->rigport.fd)
+ if (pttp->fd != rp->fd)
{
- port_close(&rs->pttport, RIG_PORT_SERIAL);
- memcpy(&rs->rigport_deprecated, &rs->rigport, sizeof(hamlib_port_t_deprecated));
+ port_close(pttp, RIG_PORT_SERIAL);
+ memcpy(&rs->rigport_deprecated, rp, sizeof(hamlib_port_t_deprecated));
}
}
@@ -1678,43 +1690,43 @@ int HAMLIB_API rig_close(RIG *rig)
case RIG_PTT_SERIAL_DTR:
// If port is already closed, do nothing
- if (rs->pttport.fd > -1)
+ if (pttp->fd > -1)
{
- ser_set_dtr(&rs->pttport, 0);
+ ser_set_dtr(pttp, 0);
- if (rs->pttport.fd != rs->rigport.fd)
+ if (pttp->fd != rp->fd)
{
- port_close(&rs->pttport, RIG_PORT_SERIAL);
- memcpy(&rs->rigport_deprecated, &rs->rigport, sizeof(hamlib_port_t_deprecated));
+ port_close(pttp, RIG_PORT_SERIAL);
+ memcpy(&rs->rigport_deprecated, rp, sizeof(hamlib_port_t_deprecated));
}
}
break;
case RIG_PTT_PARALLEL:
- par_ptt_set(&rs->pttport, RIG_PTT_OFF);
- par_close(&rs->pttport);
+ par_ptt_set(pttp, RIG_PTT_OFF);
+ par_close(pttp);
break;
case RIG_PTT_CM108:
- cm108_ptt_set(&rs->pttport, RIG_PTT_OFF);
- cm108_close(&rs->pttport);
+ cm108_ptt_set(pttp, RIG_PTT_OFF);
+ cm108_close(pttp);
break;
case RIG_PTT_GPIO:
case RIG_PTT_GPION:
- gpio_ptt_set(&rs->pttport, RIG_PTT_OFF);
- gpio_close(&rs->pttport);
+ gpio_ptt_set(pttp, RIG_PTT_OFF);
+ gpio_close(pttp);
break;
default:
rig_debug(RIG_DEBUG_ERR,
"%s: unsupported PTT type %d\n",
__func__,
- rs->pttport.type.ptt);
+ pttp->type.ptt);
}
- switch (rs->dcdport.type.dcd)
+ switch (dcdp->type.dcd)
{
case RIG_DCD_NONE:
case RIG_DCD_RIG:
@@ -1723,33 +1735,33 @@ int HAMLIB_API rig_close(RIG *rig)
case RIG_DCD_SERIAL_DSR:
case RIG_DCD_SERIAL_CTS:
case RIG_DCD_SERIAL_CAR:
- if (rs->dcdport.fd != rs->rigport.fd)
+ if (dcdp->fd != rp->fd)
{
- port_close(&rs->dcdport, RIG_PORT_SERIAL);
- memcpy(&rs->rigport_deprecated, &rs->rigport, sizeof(hamlib_port_t_deprecated));
+ port_close(dcdp, RIG_PORT_SERIAL);
+ memcpy(&rs->rigport_deprecated, rp, sizeof(hamlib_port_t_deprecated));
}
break;
case RIG_DCD_PARALLEL:
- par_close(&rs->dcdport);
+ par_close(dcdp);
break;
case RIG_DCD_GPIO:
case RIG_DCD_GPION:
- gpio_close(&rs->dcdport);
+ gpio_close(dcdp);
break;
default:
rig_debug(RIG_DEBUG_ERR,
"%s: unsupported DCD type %d\n",
__func__,
- rs->dcdport.type.dcd);
+ dcdp->type.dcd);
}
- rs->dcdport.fd = rs->pttport.fd = -1;
+ dcdp->fd = pttp->fd = -1;
- port_close(&rs->rigport, rs->rigport.type.rig);
+ port_close(rp, rp->type.rig);
// zero split so it will allow it to be set again on open for rigctld
rig->state.cache.split = 0;
@@ -1798,6 +1810,8 @@ int HAMLIB_API rig_cleanup(RIG *rig)
rig->caps->rig_cleanup(rig);
}
+ //TODO Release and null any allocated port structures
+
free(rig);
return (RIG_OK);
@@ -3373,6 +3387,8 @@ int HAMLIB_API rig_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
{
const struct rig_caps *caps;
struct rig_state *rs = &rig->state;
+ hamlib_port_t *rp = RIGPORT(rig);
+ hamlib_port_t *pttp = PTTPORT(rig);
int retcode = RIG_OK;
if (CHECK_RIG_ARG(rig))
@@ -3388,7 +3404,7 @@ int HAMLIB_API rig_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
LOCK(1);
- switch (rig->state.pttport.type.ptt)
+ switch (pttp->type.ptt)
{
case RIG_PTT_RIG:
if (ptt == RIG_PTT_ON_MIC || ptt == RIG_PTT_ON_DATA)
@@ -3536,19 +3552,19 @@ int HAMLIB_API rig_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
port when PTT is reset and seize the port when PTT is set,
this allows limited sharing of the PTT port between
applications so long as there is no contention */
- if (strcmp(rs->pttport.pathname, rs->rigport.pathname)
- && rs->pttport.fd < 0
+ if (strcmp(pttp->pathname, rp->pathname)
+ && pttp->fd < 0
&& RIG_PTT_OFF != ptt)
{
- rs->pttport.fd = ser_open(&rs->pttport);
+ pttp->fd = ser_open(pttp);
- if (rs->pttport.fd < 0)
+ if (pttp->fd < 0)
{
rig_debug(RIG_DEBUG_ERR,
"%s: cannot open PTT device \"%s\"\n",
__func__,
- rs->pttport.pathname);
+ pttp->pathname);
ELAPSED2;
RETURNFUNC(-RIG_EIO);
}
@@ -3556,7 +3572,7 @@ int HAMLIB_API rig_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
/* Needed on Linux because the serial port driver sets RTS/DTR
high on open - set both since we offer no control of
the non-PTT line and low is better than high */
- retcode = ser_set_rts(&rs->pttport, 0);
+ retcode = ser_set_rts(pttp, 0);
if (RIG_OK != retcode)
{
@@ -3565,16 +3581,16 @@ int HAMLIB_API rig_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
}
}
- retcode = ser_set_dtr(&rig->state.pttport, ptt != RIG_PTT_OFF);
+ retcode = ser_set_dtr(pttp, ptt != RIG_PTT_OFF);
rig_debug(RIG_DEBUG_TRACE, "%s: rigport=%s, pttport=%s, ptt_share=%d\n",
- __func__, rs->pttport.pathname, rs->rigport.pathname, rs->ptt_share);
+ __func__, rp->pathname, pttp->pathname, rs->ptt_share);
- if (strcmp(rs->pttport.pathname, rs->rigport.pathname)
+ if (strcmp(pttp->pathname, rp->pathname)
&& ptt == RIG_PTT_OFF && rs->ptt_share != 0)
{
/* free the port */
- ser_close(&rs->pttport);
+ ser_close(pttp);
}
break;
@@ -3585,20 +3601,20 @@ int HAMLIB_API rig_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
port when PTT is reset and seize the port when PTT is set,
this allows limited sharing of the PTT port between
applications so long as there is no contention */
- if (strcmp(rs->pttport.pathname, rs->rigport.pathname)
- && rs->pttport.fd < 0
+ if (strcmp(pttp->pathname, rp->pathname)
+ && pttp->fd < 0
&& RIG_PTT_OFF != ptt)
{
rig_debug(RIG_DEBUG_TRACE, "%s: PTT RTS debug#1\n", __func__);
- rs->pttport.fd = ser_open(&rs->pttport);
+ pttp->fd = ser_open(pttp);
- if (rs->pttport.fd < 0)
+ if (pttp->fd < 0)
{
rig_debug(RIG_DEBUG_ERR,
"%s: cannot open PTT device \"%s\"\n",
__func__,
- rs->pttport.pathname);
+ pttp->pathname);
ELAPSED2;
RETURNFUNC(-RIG_EIO);
}
@@ -3606,7 +3622,7 @@ int HAMLIB_API rig_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
/* Needed on Linux because the serial port driver sets RTS/DTR
high on open - set both since we offer no control of the
non-PTT line and low is better than high */
- retcode = ser_set_dtr(&rs->pttport, 0);
+ retcode = ser_set_dtr(pttp, 0);
if (RIG_OK != retcode)
{
@@ -3616,31 +3632,31 @@ int HAMLIB_API rig_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
}
}
- retcode = ser_set_rts(&rig->state.pttport, ptt != RIG_PTT_OFF);
+ retcode = ser_set_rts(pttp, ptt != RIG_PTT_OFF);
rig_debug(RIG_DEBUG_TRACE, "%s: rigport=%s, pttport=%s, ptt_share=%d\n",
- __func__, rs->pttport.pathname, rs->rigport.pathname, rs->ptt_share);
+ __func__, rp->pathname, pttp->pathname, rs->ptt_share);
- if (strcmp(rs->pttport.pathname, rs->rigport.pathname)
+ if (strcmp(pttp->pathname, rp->pathname)
&& ptt == RIG_PTT_OFF && rs->ptt_share != 0)
{
/* free the port */
- ser_close(&rs->pttport);
+ ser_close(pttp);
}
break;
case RIG_PTT_PARALLEL:
- retcode = par_ptt_set(&rig->state.pttport, ptt);
+ retcode = par_ptt_set(pttp, ptt);
break;
case RIG_PTT_CM108:
- retcode = cm108_ptt_set(&rig->state.pttport, ptt);
+ retcode = cm108_ptt_set(pttp, ptt);
break;
case RIG_PTT_GPIO:
case RIG_PTT_GPION:
- retcode = gpio_ptt_set(&rig->state.pttport, ptt);
+ retcode = gpio_ptt_set(pttp, ptt);
break;
case RIG_PTT_NONE:
@@ -3649,7 +3665,7 @@ int HAMLIB_API rig_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
default:
rig_debug(RIG_DEBUG_WARN, "%s: unknown PTT type=%d\n", __func__,
- rig->state.pttport.type.ptt);
+ pttp->type.ptt);
ELAPSED2;
RETURNFUNC(-RIG_EINVAL);
}
@@ -3669,7 +3685,7 @@ int HAMLIB_API rig_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
if (retcode != RIG_OK) { rig_debug(RIG_DEBUG_ERR, "%s: return code=%d\n", __func__, retcode); }
- memcpy(&rig->state.pttport_deprecated, &rig->state.pttport,
+ memcpy(&rig->state.pttport_deprecated, pttp,
sizeof(rig->state.pttport_deprecated));
if (rig->state.post_ptt_delay > 0) { hl_usleep(rig->state.post_ptt_delay * 1000); }
@@ -3698,6 +3714,8 @@ int HAMLIB_API rig_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt)
{
const struct rig_caps *caps;
struct rig_state *rs = &rig->state;
+ hamlib_port_t *rp = RIGPORT(rig);
+ hamlib_port_t *pttp = PTTPORT(rig);
int retcode = RIG_OK;
int status;
vfo_t curr_vfo;
@@ -3739,7 +3757,7 @@ int HAMLIB_API rig_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt)
LOCK(1);
- switch (rig->state.pttport.type.ptt)
+ switch (pttp->type.ptt)
{
case RIG_PTT_RIG:
case RIG_PTT_RIG_MICDATA:
@@ -3843,15 +3861,15 @@ int HAMLIB_API rig_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt)
#endif
- if (strcmp(rs->pttport.pathname, rs->rigport.pathname)
- && rs->pttport.fd < 0)
+ if (strcmp(pttp->pathname, rp->pathname)
+ && pttp->fd < 0)
{
/* port is closed so assume PTT off */
*ptt = RIG_PTT_OFF;
}
else
{
- retcode = ser_get_rts(&rig->state.pttport, &status);
+ retcode = ser_get_rts(pttp, &status);
*ptt = status ? RIG_PTT_ON : RIG_PTT_OFF;
}
@@ -3881,15 +3899,15 @@ int HAMLIB_API rig_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt)
#endif
- if (strcmp(rs->pttport.pathname, rs->rigport.pathname)
- && rs->pttport.fd < 0)
+ if (strcmp(pttp->pathname, rp->pathname)
+ && pttp->fd < 0)
{
/* port is closed so assume PTT off */
*ptt = RIG_PTT_OFF;
}
else
{
- retcode = ser_get_dtr(&rig->state.pttport, &status);
+ retcode = ser_get_dtr(pttp, &status);
*ptt = status ? RIG_PTT_ON : RIG_PTT_OFF;
}
@@ -3916,7 +3934,7 @@ int HAMLIB_API rig_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt)
RETURNFUNC(retcode);
}
- retcode = par_ptt_get(&rig->state.pttport, ptt);
+ retcode = par_ptt_get(pttp, ptt);
if (retcode == RIG_OK)
{
@@ -3945,7 +3963,7 @@ int HAMLIB_API rig_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt)
RETURNFUNC(retcode);
}
- retcode = cm108_ptt_get(&rig->state.pttport, ptt);
+ retcode = cm108_ptt_get(pttp, ptt);
if (retcode == RIG_OK)
{
@@ -3976,7 +3994,7 @@ int HAMLIB_API rig_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt)
}
elapsed_ms(&rig->state.cache.time_ptt, HAMLIB_ELAPSED_SET);
- retcode = gpio_ptt_get(&rig->state.pttport, ptt);
+ retcode = gpio_ptt_get(pttp, ptt);
ELAPSED2;
LOCK(0);
RETURNFUNC(retcode);
@@ -4015,6 +4033,7 @@ int HAMLIB_API rig_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt)
int HAMLIB_API rig_get_dcd(RIG *rig, vfo_t vfo, dcd_t *dcd)
{
const struct rig_caps *caps;
+ hamlib_port_t *dcdp = DCDPORT(rig);
int retcode, rc2, status;
vfo_t curr_vfo;
@@ -4035,7 +4054,7 @@ int HAMLIB_API rig_get_dcd(RIG *rig, vfo_t vfo, dcd_t *dcd)
caps = rig->caps;
- switch (rig->state.dcdport.type.dcd)
+ switch (dcdp->type.dcd)
{
case RIG_DCD_RIG:
if (caps->get_dcd == NULL)
@@ -4086,24 +4105,24 @@ int HAMLIB_API rig_get_dcd(RIG *rig, vfo_t vfo, dcd_t *dcd)
break;
case RIG_DCD_SERIAL_CTS:
- retcode = ser_get_cts(&rig->state.dcdport, &status);
- memcpy(&rig->state.dcdport_deprecated, &rig->state.dcdport,
+ retcode = ser_get_cts(dcdp, &status);
+ memcpy(&rig->state.dcdport_deprecated, dcdp,
sizeof(rig->state.dcdport_deprecated));
*dcd = status ? RIG_DCD_ON : RIG_DCD_OFF;
ELAPSED2;
RETURNFUNC(retcode);
case RIG_DCD_SERIAL_DSR:
- retcode = ser_get_dsr(&rig->state.dcdport, &status);
- memcpy(&rig->state.dcdport_deprecated, &rig->state.dcdport,
+ retcode = ser_get_dsr(dcdp, &status);
+ memcpy(&rig->state.dcdport_deprecated, dcdp,
sizeof(rig->state.dcdport_deprecated));
*dcd = status ? RIG_DCD_ON : RIG_DCD_OFF;
ELAPSED2;
RETURNFUNC(retcode);
case RIG_DCD_SERIAL_CAR:
- retcode = ser_get_car(&rig->state.dcdport, &status);
- memcpy(&rig->state.dcdport_deprecated, &rig->state.dcdport,
+ retcode = ser_get_car(dcdp, &status);
+ memcpy(&rig->state.dcdport_deprecated, dcdp,
sizeof(rig->state.dcdport_deprecated));
*dcd = status ? RIG_DCD_ON : RIG_DCD_OFF;
ELAPSED2;
@@ -4111,16 +4130,16 @@ int HAMLIB_API rig_get_dcd(RIG *rig, vfo_t vfo, dcd_t *dcd)
case RIG_DCD_PARALLEL:
- retcode = par_dcd_get(&rig->state.dcdport, dcd);
- memcpy(&rig->state.dcdport_deprecated, &rig->state.dcdport,
+ retcode = par_dcd_get(dcdp, dcd);
+ memcpy(&rig->state.dcdport_deprecated, dcdp,
sizeof(rig->state.dcdport_deprecated));
ELAPSED2;
RETURNFUNC(retcode);
case RIG_DCD_GPIO:
case RIG_DCD_GPION:
- retcode = gpio_dcd_get(&rig->state.dcdport, dcd);
- memcpy(&rig->state.dcdport_deprecated, &rig->state.dcdport,
+ retcode = gpio_dcd_get(dcdp, dcd);
+ memcpy(&rig->state.dcdport_deprecated, dcdp,
sizeof(rig->state.dcdport_deprecated));
ELAPSED2;
RETURNFUNC(retcode);
@@ -6499,7 +6518,7 @@ int HAMLIB_API rig_set_powerstat(RIG *rig, powerstat_t status)
}
// if anything is queued up flush it
- rig_flush_force(&rig->state.rigport, 1);
+ rig_flush_force(RIGPORT(rig), 1);
ELAPSED2;
RETURNFUNC(retcode);
}
@@ -8241,7 +8260,7 @@ void *async_data_handler(void *arg)
if (rs->transaction_active)
{
unsigned char data = (unsigned char) result;
- write_block_sync_error(&rs->rigport, &data, 1);
+ write_block_sync_error(RIGPORT(rig), &data, 1);
}
// TODO: error handling -> store errors in rig state -> to be exposed in async snapshot packets
@@ -8275,7 +8294,7 @@ void *async_data_handler(void *arg)
}
else
{
- result = write_block_sync(&rs->rigport, frame, frame_length);
+ result = write_block_sync(RIGPORT(rig), frame, frame_length);
if (result < 0)
{
@@ -8459,12 +8478,12 @@ extern int read_icom_frame(hamlib_port_t *p, const unsigned char rxbuffer[],
HAMLIB_EXPORT(int) rig_send_raw(RIG *rig, const unsigned char *send,
int send_len, unsigned char *reply, int reply_len, unsigned char *term)
{
- struct rig_state *rs = &rig->state;
int nbytes;
int retval;
+ hamlib_port_t *rp = RIGPORT(rig);
int simulate = rig->caps->rig_model == RIG_MODEL_DUMMY ||
rig->caps->rig_model == RIG_MODEL_NONE ||
- rs->rigport.rig == RIG_PORT_NONE;
+ rp->rig == RIG_PORT_NONE;
ENTERFUNC;
ELAPSED1;
@@ -8481,7 +8500,7 @@ HAMLIB_EXPORT(int) rig_send_raw(RIG *rig, const unsigned char *send,
}
else
{
- retval = write_block(&rs->rigport, send, send_len);
+ retval = write_block(rp, send, send_len);
if (retval < 0)
{
@@ -8506,25 +8525,25 @@ HAMLIB_EXPORT(int) rig_send_raw(RIG *rig, const unsigned char *send,
if (term == NULL)
{
rig_debug(RIG_DEBUG_VERBOSE, "%s: reading binary frame\n", __func__);
- retval = read_string(&rs->rigport, buf, reply_len, NULL, 0, 0, 1);
+ retval = read_string(rp, buf, reply_len, NULL, 0, 0, 1);
}
else if (*term == 0xfd) // then we want an Icom frame
{
rig_debug(RIG_DEBUG_VERBOSE, "%s: reading icom frame\n", __func__);
- retval = read_icom_frame(&rs->rigport, buf, sizeof(buf));
+ retval = read_icom_frame(rp, buf, sizeof(buf));
}
else // we'll assume the provided terminator works
{
rig_debug(RIG_DEBUG_VERBOSE, "%s: reading frame terminated by 0x%x\n", __func__,
*term);
- retval = read_string(&rs->rigport, buf, sizeof(buf), (const char *)term,
+ retval = read_string(rp, buf, sizeof(buf), (const char *)term,
1, 0, 1);
}
if (retval < RIG_OK)
{
rig_debug(RIG_DEBUG_ERR, "%s: read_string, result=%d\n", __func__, retval);
- rig_flush_force(&rs->rigport, 1);
+ rig_flush_force(rp, 1);
set_transaction_inactive(rig);
RETURNFUNC(retval);
}
@@ -8535,7 +8554,7 @@ HAMLIB_EXPORT(int) rig_send_raw(RIG *rig, const unsigned char *send,
{
rig_debug(RIG_DEBUG_ERR, "%s: reply_len(%d) less than reply from rig(%d)\n",
__func__, reply_len, nbytes);
- rig_flush_force(&rs->rigport, 1);
+ rig_flush_force(rp, 1);
set_transaction_inactive(rig);
return -RIG_EINVAL;
}
@@ -8545,12 +8564,12 @@ HAMLIB_EXPORT(int) rig_send_raw(RIG *rig, const unsigned char *send,
}
else
{
- rig_flush_force(&rs->rigport, 1);
+ rig_flush_force(rp, 1);
set_transaction_inactive(rig);
RETURNFUNC(retval);
}
- rig_flush_force(&rs->rigport, 1);
+ rig_flush_force(rp, 1);
set_transaction_inactive(rig);
ELAPSED2;
commit aa9c3b39baf9249e8bc3c8449971daa0cf4ea864
Author: George Baltz N3GB <Geo...@gm...>
Date: Sat Jan 13 11:36:57 2024 -0500
Convert more files in src/
Leaves only src/rig.c
diff --git a/src/multicast.c b/src/multicast.c
index f610cf067..189d15b7f 100644
--- a/src/multicast.c
+++ b/src/multicast.c
@@ -297,7 +297,7 @@ static int multicast_send_json(RIG *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,
- rig->state.rigport.pathname);
+ RIGPORT(rig)->pathname);
strcat(msg, "{\n");
json_add_string(msg, "ID", buf, 1);
json_add_time(msg, 1);
@@ -339,7 +339,7 @@ void *multicast_thread_rx(void *vrig)
while (rig->state.multicast->runflag)
{
#if 0
- ret = read_string(&rig->state.rigport, (unsigned char *) buf, sizeof(buf), "\n",
+ ret = read_string(RIGPORT(rig), (unsigned char *) buf, sizeof(buf), "\n",
1,
0, 1);
#endif
@@ -652,8 +652,8 @@ int main(int argc, const char *argv[])
return 1;
}
- strncpy(rig->state.rigport.pathname, "/dev/ttyUSB0", HAMLIB_FILPATHLEN - 1);
- rig->state.rigport.parm.serial.rate = 38400;
+ strncpy(RIGPORT(rig)->pathname, "/dev/ttyUSB0", HAMLIB_FILPATHLEN - 1);
+ RIGPORT(rig)->parm.serial.rate = 38400;
rig_open(rig);
multicast_init(rig, "224.0.0.1", 4532);
pthread_join(rig->state.multicast->threadid, NULL);
diff --git a/src/serial.c b/src/serial.c
index f891b1273..302e67b0c 100644
--- a/src/serial.c
+++ b/src/serial.c
@@ -1051,7 +1051,7 @@ int HAMLIB_API ser_set_rts(hamlib_port_t *p, int state)
/**
* \brief Get RTS bit
- * \param p supposed to be &rig->state.rigport
+ * \param p supposed to be RIGPORT(rig)
* \param state non-NULL
*/
int HAMLIB_API ser_get_rts(hamlib_port_t *p, int *state)
@@ -1134,7 +1134,7 @@ int HAMLIB_API ser_set_dtr(hamlib_port_t *p, int state)
/**
* \brief Get DTR bit
- * \param p supposed to be &rig->state.rigport
+ * \param p supposed to be RIGPORT(rig)
* \param state non-NULL
*/
int HAMLIB_API ser_get_dtr(hamlib_port_t *p, int *state)
@@ -1186,7 +1186,7 @@ int HAMLIB_API ser_set_brk(const hamlib_port_t *p, int state)
/**
* \brief Get Carrier (CI?) bit
- * \param p supposed to be &rig->state.rigport
+ * \param p supposed to be RIGPORT(rig)
* \param state non-NULL
*/
int HAMLIB_API ser_get_car(hamlib_port_t *p, int *state)
@@ -1209,7 +1209,7 @@ int HAMLIB_API ser_get_car(hamlib_port_t *p, int *state)
/**
* \brief Get Clear to Send (CTS) bit
- * \param p supposed to be &rig->state.rigport
+ * \param p supposed to be RIGPORT(rig)
* \param state non-NULL
*/
int HAMLIB_API ser_get_cts(hamlib_port_t *p, int *state)
@@ -1232,7 +1232,7 @@ int HAMLIB_API ser_get_cts(hamlib_port_t *p, int *state)
/**
* \brief Get Data Set Ready (DSR) bit
- * \param p supposed to be &rig->state.rigport
+ * \param p supposed to be RIGPORT(rig)
* \param state non-NULL
*/
int HAMLIB_API ser_get_dsr(hamlib_port_t *p, int *state)
diff --git a/src/snapshot_data.c b/src/snapshot_data.c
index 52f9a1333..7ddd53de2 100644
--- a/src/snapshot_data.c
+++ b/src/snapshot_data.c
@@ -22,7 +22,7 @@ static int snapshot_serialize_rig(cJSON *rig_node, RIG *rig)
cJSON *id_node = cJSON_CreateObject();
cJSON_AddStringToObject(id_node, "model", rig->caps->model_name);
- cJSON_AddStringToObject(id_node, "endpoint", r...
[truncated message content] |
